diff --git a/crates/codespell-dict/src/dict_codegen.rs b/crates/codespell-dict/src/dict_codegen.rs
index 3f1f975..4090892 100644
--- a/crates/codespell-dict/src/dict_codegen.rs
+++ b/crates/codespell-dict/src/dict_codegen.rs
@@ -1,6 +1,6 @@
 // This file is @generated crates/codespell-dict/tests/codegen.rs
 
-pub static WORD_DICTIONARY: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICTIONARY: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("1nd"),
         dictgen::InsensitiveStr::Ascii("2rd"),
diff --git a/crates/codespell-dict/tests/codegen.rs b/crates/codespell-dict/tests/codegen.rs
index a263454..2910fa8 100644
--- a/crates/codespell-dict/tests/codegen.rs
+++ b/crates/codespell-dict/tests/codegen.rs
@@ -54,7 +54,7 @@ fn generate<W: std::io::Write>(file: &mut W) {
     dictgen::DictGen::new()
         .name("WORD_DICTIONARY")
         .value_type("&[&str]")
-        .table()
+        .ordered_map()
         .write(file, dict.map(|kv| (kv.0, format!("&{:?}", kv.1))))
         .unwrap();
 }
diff --git a/crates/dictgen/src/gen.rs b/crates/dictgen/src/gen.rs
index 52fb39b..34e50bd 100644
--- a/crates/dictgen/src/gen.rs
+++ b/crates/dictgen/src/gen.rs
@@ -35,16 +35,16 @@ impl<'g> DictGen<'g> {
     }
 
     #[cfg(feature = "map")]
-    pub fn map(self) -> crate::DictMapGen<'g> {
-        crate::DictMapGen { gen: self }
+    pub fn map(self) -> crate::MapGen<'g> {
+        crate::MapGen { gen: self }
     }
 
-    pub fn table(self) -> crate::DictTableGen<'g> {
-        crate::DictTableGen { gen: self }
+    pub fn ordered_map(self) -> crate::OrderedMapGen<'g> {
+        crate::OrderedMapGen { gen: self }
     }
 
-    pub fn trie(self) -> crate::DictTrieGen<'g> {
-        crate::DictTrieGen {
+    pub fn trie(self) -> crate::TrieGen<'g> {
+        crate::TrieGen {
             gen: self,
             limit: 64,
         }
diff --git a/crates/dictgen/src/lib.rs b/crates/dictgen/src/lib.rs
index 5b2fb82..fd1e330 100644
--- a/crates/dictgen/src/lib.rs
+++ b/crates/dictgen/src/lib.rs
@@ -7,7 +7,7 @@ mod gen;
 mod insensitive;
 #[cfg(feature = "map")]
 mod map;
-mod table;
+mod ordered_map;
 mod trie;
 
 #[cfg(feature = "codegen")]
@@ -15,5 +15,5 @@ pub use gen::*;
 pub use insensitive::*;
 #[cfg(feature = "map")]
 pub use map::*;
-pub use table::*;
+pub use ordered_map::*;
 pub use trie::*;
diff --git a/crates/dictgen/src/map.rs b/crates/dictgen/src/map.rs
index 8cda1e7..93a7d4c 100644
--- a/crates/dictgen/src/map.rs
+++ b/crates/dictgen/src/map.rs
@@ -1,10 +1,10 @@
 #[cfg(feature = "codegen")]
-pub struct DictMapGen<'g> {
+pub struct MapGen<'g> {
     pub(crate) gen: crate::DictGen<'g>,
 }
 
 #[cfg(feature = "codegen")]
-impl DictMapGen<'_> {
+impl MapGen<'_> {
     pub fn write<'d, W: std::io::Write, V: std::fmt::Display>(
         &self,
         file: &mut W,
@@ -44,7 +44,7 @@ impl DictMapGen<'_> {
 
         writeln!(
             file,
-            "pub static {name}: dictgen::DictMap<{value_type}> = dictgen::DictMap {{"
+            "pub static {name}: dictgen::Map<{value_type}> = dictgen::Map {{"
         )?;
         writeln!(file, "    map: {builder},")?;
         writeln!(file, "    range: {smallest}..={largest},")?;
@@ -54,12 +54,12 @@ impl DictMapGen<'_> {
     }
 }
 
-pub struct DictMap<V: 'static> {
+pub struct Map<V: 'static> {
     pub map: phf::Map<crate::InsensitiveStr<'static>, V>,
     pub range: std::ops::RangeInclusive<usize>,
 }
 
-impl<V> DictMap<V> {
+impl<V> Map<V> {
     #[inline]
     pub fn find(&self, word: &'_ unicase::UniCase<&str>) -> Option<&V> {
         if self.range.contains(&word.len()) {
diff --git a/crates/dictgen/src/table.rs b/crates/dictgen/src/ordered_map.rs
similarity index 90%
rename from crates/dictgen/src/table.rs
rename to crates/dictgen/src/ordered_map.rs
index 0b78d98..a9ab3e7 100644
--- a/crates/dictgen/src/table.rs
+++ b/crates/dictgen/src/ordered_map.rs
@@ -1,10 +1,10 @@
 #[cfg(feature = "codegen")]
-pub struct DictTableGen<'g> {
+pub struct OrderedMapGen<'g> {
     pub(crate) gen: crate::DictGen<'g>,
 }
 
 #[cfg(feature = "codegen")]
-impl DictTableGen<'_> {
+impl OrderedMapGen<'_> {
     pub fn write<'d, W: std::io::Write, V: std::fmt::Display>(
         &self,
         file: &mut W,
@@ -21,7 +21,7 @@ impl DictTableGen<'_> {
 
         writeln!(
             file,
-            "pub static {name}: dictgen::DictTable<{value_type}> = dictgen::DictTable {{"
+            "pub static {name}: dictgen::OrderedMap<{value_type}> = dictgen::OrderedMap {{"
         )?;
         writeln!(file, "    keys: &[")?;
         for (key, _value) in data.iter() {
@@ -52,13 +52,13 @@ impl DictTableGen<'_> {
     }
 }
 
-pub struct DictTable<V: 'static> {
+pub struct OrderedMap<V: 'static> {
     pub keys: &'static [crate::InsensitiveStr<'static>],
     pub values: &'static [V],
     pub range: core::ops::RangeInclusive<usize>,
 }
 
-impl<V> DictTable<V> {
+impl<V> OrderedMap<V> {
     #[inline]
     pub fn find(&self, word: &'_ unicase::UniCase<&str>) -> Option<&'static V> {
         if self.range.contains(&word.len()) {
diff --git a/crates/dictgen/src/trie.rs b/crates/dictgen/src/trie.rs
index f1ff42f..7c74fb7 100644
--- a/crates/dictgen/src/trie.rs
+++ b/crates/dictgen/src/trie.rs
@@ -1,11 +1,11 @@
 #[cfg(feature = "codegen")]
-pub struct DictTrieGen<'g> {
+pub struct TrieGen<'g> {
     pub(crate) gen: crate::DictGen<'g>,
     pub(crate) limit: usize,
 }
 
 #[cfg(feature = "codegen")]
-impl DictTrieGen<'_> {
+impl TrieGen<'_> {
     pub fn limit(mut self, limit: usize) -> Self {
         self.limit = limit;
         self
@@ -25,13 +25,13 @@ impl DictTrieGen<'_> {
     }
 }
 
-pub struct DictTrie<V: 'static> {
-    pub root: &'static DictTrieNode<V>,
-    pub unicode: &'static crate::DictTable<V>,
+pub struct Trie<V: 'static> {
+    pub root: &'static TrieNode<V>,
+    pub unicode: &'static crate::OrderedMap<V>,
     pub range: core::ops::RangeInclusive<usize>,
 }
 
-impl<V> DictTrie<V> {
+impl<V> Trie<V> {
     #[inline]
     pub fn find(&self, word: &'_ unicase::UniCase<&str>) -> Option<&'static V> {
         if word
@@ -54,7 +54,7 @@ impl<V> DictTrie<V> {
         let mut child = &self.root;
         for i in 0..word.len() {
             match child.children {
-                DictTrieChild::Nested(n) => {
+                TrieChild::Nested(n) => {
                     let byte = word[i];
                     let index = if byte.is_ascii_lowercase() {
                         byte - b'a'
@@ -70,7 +70,7 @@ impl<V> DictTrie<V> {
                         return None;
                     }
                 }
-                DictTrieChild::Flat(t) => {
+                TrieChild::Flat(t) => {
                     let remaining = &word[i..word.len()];
                     // Unsafe: Everything before has been proven to be ASCII, so this should be
                     // safe.
@@ -84,14 +84,14 @@ impl<V> DictTrie<V> {
     }
 }
 
-pub struct DictTrieNode<V: 'static> {
-    pub children: DictTrieChild<V>,
+pub struct TrieNode<V: 'static> {
+    pub children: TrieChild<V>,
     pub value: Option<V>,
 }
 
-pub enum DictTrieChild<V: 'static> {
-    Nested(&'static [Option<&'static DictTrieNode<V>>; 26]),
-    Flat(&'static crate::DictTable<V>),
+pub enum TrieChild<V: 'static> {
+    Nested(&'static [Option<&'static TrieNode<V>>; 26]),
+    Flat(&'static crate::OrderedMap<V>),
 }
 
 #[cfg(feature = "codegen")]
@@ -110,7 +110,7 @@ mod codegen {
 
         writeln!(
             file,
-            "pub static {name}: dictgen::DictTrie<{value_type}> = dictgen::DictTrie {{"
+            "pub static {name}: dictgen::Trie<{value_type}> = dictgen::Trie {{"
         )?;
         writeln!(file, "    root: &{},", gen_node_name(name, ""))?;
         writeln!(file, "    unicode: &{},", &unicode_table_name)?;
@@ -126,7 +126,7 @@ mod codegen {
         crate::DictGen::new()
             .name(&unicode_table_name)
             .value_type(value_type)
-            .table()
+            .ordered_map()
             .write(file, root.unicode.into_iter())?;
         writeln!(file)?;
 
@@ -136,7 +136,7 @@ mod codegen {
             let children_name = gen_children_name(name, &start);
             writeln!(
                 file,
-                "static {node_name}: dictgen::DictTrieNode<{value_type}> = dictgen::DictTrieNode {{"
+                "static {node_name}: dictgen::TrieNode<{value_type}> = dictgen::TrieNode {{"
             )?;
             writeln!(
                 file,
@@ -156,7 +156,7 @@ mod codegen {
                 DynChild::Nested(n) => {
                     writeln!(
                         file,
-                        "static {children_name}: [Option<&dictgen::DictTrieNode<{value_type}>>; 26] = [",
+                        "static {children_name}: [Option<&dictgen::TrieNode<{value_type}>>; 26] = [",
                     )?;
                     for b in b'a'..=b'z' {
                         if let Some(child) = n.get(&b) {
@@ -178,7 +178,7 @@ mod codegen {
                     crate::DictGen::new()
                         .name(&children_name)
                         .value_type(value_type)
-                        .table()
+                        .ordered_map()
                         .write(file, table_input)?;
                 }
             }
@@ -211,8 +211,8 @@ mod codegen {
 
     fn gen_type_name<V>(leaf: &DynChild<'_, V>) -> &'static str {
         match leaf {
-            DynChild::Nested(_) => "dictgen::DictTrieChild::Nested",
-            DynChild::Flat(_) => "dictgen::DictTrieChild::Flat",
+            DynChild::Nested(_) => "dictgen::TrieChild::Nested",
+            DynChild::Flat(_) => "dictgen::TrieChild::Flat",
         }
     }
 
diff --git a/crates/misspell-dict/src/dict_codegen.rs b/crates/misspell-dict/src/dict_codegen.rs
index 8dc8baa..a4abd97 100644
--- a/crates/misspell-dict/src/dict_codegen.rs
+++ b/crates/misspell-dict/src/dict_codegen.rs
@@ -1,6 +1,6 @@
 // This file is @generated by crates/misspell-dict/tests/codegen.rs
 
-pub static MAIN_DICTIONARY: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static MAIN_DICTIONARY: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abandenment"),
         dictgen::InsensitiveStr::Ascii("abandining"),
@@ -56101,7 +56101,7 @@ pub static MAIN_DICTIONARY: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     ],
     range: 3..=19,
 };
-pub static AMERICAN_DICTIONARY: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static AMERICAN_DICTIONARY: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("accessorise"),
         dictgen::InsensitiveStr::Ascii("accessorised"),
@@ -59346,7 +59346,7 @@ pub static AMERICAN_DICTIONARY: dictgen::DictTable<&[&str]> = dictgen::DictTable
     ],
     range: 4..=20,
 };
-pub static BRITISH_DICTIONARY: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static BRITISH_DICTIONARY: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("accessorize"),
         dictgen::InsensitiveStr::Ascii("accessorized"),
diff --git a/crates/misspell-dict/tests/codegen.rs b/crates/misspell-dict/tests/codegen.rs
index cc80c14..747009f 100644
--- a/crates/misspell-dict/tests/codegen.rs
+++ b/crates/misspell-dict/tests/codegen.rs
@@ -30,7 +30,7 @@ fn generate<W: std::io::Write>(file: &mut W) {
     dictgen::DictGen::new()
         .name("MAIN_DICTIONARY")
         .value_type("&[&str]")
-        .table()
+        .ordered_map()
         .write(
             file,
             main.into_iter().map(|kv| (kv.0, format!("&{:?}", kv.1))),
@@ -40,7 +40,7 @@ fn generate<W: std::io::Write>(file: &mut W) {
     dictgen::DictGen::new()
         .name("AMERICAN_DICTIONARY")
         .value_type("&[&str]")
-        .table()
+        .ordered_map()
         .write(
             file,
             american
@@ -52,7 +52,7 @@ fn generate<W: std::io::Write>(file: &mut W) {
     dictgen::DictGen::new()
         .name("BRITISH_DICTIONARY")
         .value_type("&[&str]")
-        .table()
+        .ordered_map()
         .write(
             file,
             british.into_iter().map(|kv| (kv.0, format!("&{:?}", kv.1))),
diff --git a/crates/typos-dict/benches/benches/main.rs b/crates/typos-dict/benches/benches/main.rs
index ab6dfe7..63b5cf4 100644
--- a/crates/typos-dict/benches/benches/main.rs
+++ b/crates/typos-dict/benches/benches/main.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::wildcard_imports)]
 
 mod map_codegen;
-mod table_codegen;
+mod ordered_map_codegen;
 mod trie_codegen;
 
 mod miss {
@@ -20,8 +20,8 @@ mod miss {
     }
 
     #[divan::bench(args = [unicase::UniCase::new(MISS)])]
-    fn table(word: unicase::UniCase<&str>) -> Option<&'static &[&str]> {
-        table_codegen::WORD.find(&word)
+    fn ordered_map(word: unicase::UniCase<&str>) -> Option<&'static &[&str]> {
+        ordered_map_codegen::WORD.find(&word)
     }
 }
 
@@ -41,8 +41,8 @@ mod hit {
     }
 
     #[divan::bench(args = [unicase::UniCase::new(HIT)])]
-    fn table(word: unicase::UniCase<&str>) -> Option<&'static &[&str]> {
-        table_codegen::WORD.find(&word)
+    fn ordered_map(word: unicase::UniCase<&str>) -> Option<&'static &[&str]> {
+        ordered_map_codegen::WORD.find(&word)
     }
 }
 
diff --git a/crates/typos-dict/benches/benches/map_codegen.rs b/crates/typos-dict/benches/benches/map_codegen.rs
index e1225b6..3bec624 100644
--- a/crates/typos-dict/benches/benches/map_codegen.rs
+++ b/crates/typos-dict/benches/benches/map_codegen.rs
@@ -2,7 +2,7 @@
 #![allow(clippy::unreadable_literal)]
 #![allow(unreachable_pub)]
 
-pub static WORD: dictgen::DictMap<&[&str]> = dictgen::DictMap {
+pub static WORD: dictgen::Map<&[&str]> = dictgen::Map {
     map: ::phf::Map {
         key: 12913932095322966823,
         disps: &[
diff --git a/crates/typos-dict/benches/benches/table_codegen.rs b/crates/typos-dict/benches/benches/ordered_map_codegen.rs
similarity index 99%
rename from crates/typos-dict/benches/benches/table_codegen.rs
rename to crates/typos-dict/benches/benches/ordered_map_codegen.rs
index b81c9da..b82b0c7 100644
--- a/crates/typos-dict/benches/benches/table_codegen.rs
+++ b/crates/typos-dict/benches/benches/ordered_map_codegen.rs
@@ -2,7 +2,7 @@
 #![allow(clippy::unreadable_literal)]
 #![allow(unreachable_pub)]
 
-pub static WORD: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aaccess"),
         dictgen::InsensitiveStr::Ascii("aaccessibility"),
diff --git a/crates/typos-dict/benches/benches/trie_codegen.rs b/crates/typos-dict/benches/benches/trie_codegen.rs
index ad1b778..0a746e2 100644
--- a/crates/typos-dict/benches/benches/trie_codegen.rs
+++ b/crates/typos-dict/benches/benches/trie_codegen.rs
@@ -2,13 +2,13 @@
 #![allow(clippy::unreadable_literal)]
 #![allow(unreachable_pub)]
 
-pub static WORD: dictgen::DictTrie<&[&str]> = dictgen::DictTrie {
+pub static WORD: dictgen::Trie<&[&str]> = dictgen::Trie {
     root: &WORD_NODE,
     unicode: &WORD_UNICODE_TABLE,
     range: 2..=34,
 };
 
-pub static WORD_UNICODE_TABLE: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNICODE_TABLE: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Unicode("clockwíse"),
         dictgen::InsensitiveStr::Unicode("paínt"),
@@ -38,12 +38,12 @@ pub static WORD_UNICODE_TABLE: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=11,
 };
 
-static WORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHILDREN),
+static WORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHILDREN),
     value: None,
 };
 
-static WORD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_A_NODE),
     Some(&WORD_B_NODE),
     Some(&WORD_C_NODE),
@@ -72,12 +72,12 @@ static WORD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_Z_NODE),
 ];
 
-static WORD_Z_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_Z_CHILDREN),
+static WORD_Z_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_Z_CHILDREN),
     value: None,
 };
 
-static WORD_Z_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_Z_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ZA_NODE),
     None,
     None,
@@ -106,12 +106,12 @@ static WORD_Z_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ZY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZY_CHILDREN),
+static WORD_ZY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lophone"),
         dictgen::InsensitiveStr::Ascii("lophones"),
@@ -120,12 +120,12 @@ pub static WORD_ZY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_ZU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZU_CHILDREN),
+static WORD_ZU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cheenei"),
         dictgen::InsensitiveStr::Ascii("cheeni"),
@@ -147,12 +147,12 @@ pub static WORD_ZU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_ZO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZO_CHILDREN),
+static WORD_ZO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("briust"),
         dictgen::InsensitiveStr::Ascii("inism"),
@@ -198,23 +198,23 @@ pub static WORD_ZO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ZL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZL_CHILDREN),
+static WORD_ZL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ot")],
     values: &[&["slot"]],
     range: 2..=2,
 };
 
-static WORD_ZI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZI_CHILDREN),
+static WORD_ZI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mbabe"),
         dictgen::InsensitiveStr::Ascii("mbabew"),
@@ -262,12 +262,12 @@ pub static WORD_ZI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ZE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZE_CHILDREN),
+static WORD_ZE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alotes"),
         dictgen::InsensitiveStr::Ascii("aloths"),
@@ -307,12 +307,12 @@ pub static WORD_ZE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ZA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZA_CHILDREN),
+static WORD_ZA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elots"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -321,12 +321,12 @@ pub static WORD_ZA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_Y_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_Y_CHILDREN),
+static WORD_Y_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_Y_CHILDREN),
     value: None,
 };
 
-static WORD_Y_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_Y_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_YA_NODE),
     None,
     None,
@@ -355,23 +355,23 @@ static WORD_Y_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_YY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YY_CHILDREN),
+static WORD_YY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YY_CHILDREN),
     value: None,
 };
 
-pub static WORD_YY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ou")],
     values: &[&["you"]],
     range: 2..=2,
 };
 
-static WORD_YU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YU_CHILDREN),
+static WORD_YU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YU_CHILDREN),
     value: None,
 };
 
-pub static WORD_YU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("foric"),
         dictgen::InsensitiveStr::Ascii("forically"),
@@ -393,12 +393,12 @@ pub static WORD_YU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_YT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YT_CHILDREN),
+static WORD_YT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YT_CHILDREN),
     value: None,
 };
 
-pub static WORD_YT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -408,34 +408,34 @@ pub static WORD_YT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_YS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YS_CHILDREN),
+static WORD_YS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YS_CHILDREN),
     value: None,
 };
 
-pub static WORD_YS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["yes", "use", "nyse"]],
     range: 1..=1,
 };
 
-static WORD_YR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YR_CHILDREN),
+static WORD_YR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YR_CHILDREN),
     value: None,
 };
 
-pub static WORD_YR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ea")],
     values: &[&["year"]],
     range: 2..=2,
 };
 
-static WORD_YP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YP_CHILDREN),
+static WORD_YP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YP_CHILDREN),
     value: None,
 };
 
-pub static WORD_YP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("ou"),
@@ -447,12 +447,12 @@ pub static WORD_YP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_YO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YO_CHILDREN),
+static WORD_YO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YO_CHILDREN),
     value: None,
 };
 
-pub static WORD_YO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esmite"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -560,23 +560,23 @@ pub static WORD_YO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_YM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YM_CHILDREN),
+static WORD_YM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YM_CHILDREN),
     value: None,
 };
 
-pub static WORD_YM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bols")],
     values: &[&["symbols"]],
     range: 4..=4,
 };
 
-static WORD_YI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YI_CHILDREN),
+static WORD_YI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YI_CHILDREN),
     value: None,
 };
 
-pub static WORD_YI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eldin"),
         dictgen::InsensitiveStr::Ascii("eleded"),
@@ -588,12 +588,12 @@ pub static WORD_YI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_YH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YH_CHILDREN),
+static WORD_YH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YH_CHILDREN),
     value: None,
 };
 
-pub static WORD_YH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -603,12 +603,12 @@ pub static WORD_YH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_YE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YE_CHILDREN),
+static WORD_YE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YE_CHILDREN),
     value: None,
 };
 
-pub static WORD_YE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arm"),
         dictgen::InsensitiveStr::Ascii("asr"),
@@ -660,12 +660,12 @@ pub static WORD_YE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_YA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YA_CHILDREN),
+static WORD_YA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YA_CHILDREN),
     value: None,
 };
 
-pub static WORD_YA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ching"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -685,12 +685,12 @@ pub static WORD_YA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_X_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_X_CHILDREN),
+static WORD_X_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_X_CHILDREN),
     value: None,
 };
 
-pub static WORD_X_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_X_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("describe"),
         dictgen::InsensitiveStr::Ascii("dpf"),
@@ -754,12 +754,12 @@ pub static WORD_X_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_W_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_W_CHILDREN),
+static WORD_W_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_W_CHILDREN),
     value: None,
 };
 
-static WORD_W_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_W_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WA_NODE),
     None,
     None,
@@ -788,12 +788,12 @@ static WORD_W_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WY_CHILDREN),
+static WORD_WY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("th"),
@@ -803,23 +803,23 @@ pub static WORD_WY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WW_CHILDREN),
+static WORD_WW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WW_CHILDREN),
     value: None,
 };
 
-pub static WORD_WW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ith")],
     values: &[&["with"]],
     range: 3..=3,
 };
 
-static WORD_WU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WU_CHILDREN),
+static WORD_WU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WU_CHILDREN),
     value: None,
 };
 
-pub static WORD_WU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("estions"),
         dictgen::InsensitiveStr::Ascii("ld"),
@@ -841,12 +841,12 @@ pub static WORD_WU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_WT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WT_CHILDREN),
+static WORD_WT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("iches"),
@@ -857,12 +857,12 @@ pub static WORD_WT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WS_CHILDREN),
+static WORD_WS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ee"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -871,12 +871,12 @@ pub static WORD_WS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_WR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WR_CHILDREN),
+static WORD_WR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WR_CHILDREN),
     value: None,
 };
 
-static WORD_WR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WRA_NODE),
     None,
     None,
@@ -905,12 +905,12 @@ static WORD_WR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRY_CHILDREN),
+static WORD_WRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("th"),
         dictgen::InsensitiveStr::Ascii("thed"),
@@ -921,12 +921,12 @@ pub static WORD_WRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_WRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRT_CHILDREN),
+static WORD_WRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eched"),
         dictgen::InsensitiveStr::Ascii("ie"),
@@ -936,12 +936,12 @@ pub static WORD_WRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_WRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRO_CHILDREN),
+static WORD_WRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -983,23 +983,23 @@ pub static WORD_WRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRN_CHILDREN),
+static WORD_WRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("agler")],
     values: &[&["wrangler"]],
     range: 5..=5,
 };
 
-static WORD_WRK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRK_CHILDREN),
+static WORD_WRK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRK_CHILDREN),
     value: Some(&["work"]),
 };
 
-pub static WORD_WRK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("load"),
         dictgen::InsensitiveStr::Ascii("loads"),
@@ -1008,12 +1008,12 @@ pub static WORD_WRK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_WRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRI_CHILDREN),
+static WORD_WRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("tebufer"),
@@ -1063,12 +1063,12 @@ pub static WORD_WRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_WRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRE_CHILDREN),
+static WORD_WRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckign"),
         dictgen::InsensitiveStr::Ascii("cthed"),
@@ -1102,12 +1102,12 @@ pub static WORD_WRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_WRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRA_CHILDREN),
+static WORD_WRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("app"),
         dictgen::InsensitiveStr::Ascii("apped"),
@@ -1157,34 +1157,34 @@ pub static WORD_WRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_WQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WQ_CHILDREN),
+static WORD_WQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_WQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["was"]],
     range: 1..=1,
 };
 
-static WORD_WP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WP_CHILDREN),
+static WORD_WP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uld")],
     values: &[&["would"]],
     range: 3..=3,
 };
 
-static WORD_WO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WO_CHILDREN),
+static WORD_WO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WO_CHILDREN),
     value: None,
 };
 
-static WORD_WO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WOA_NODE),
     None,
     None,
@@ -1213,12 +1213,12 @@ static WORD_WO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOU_CHILDREN),
+static WORD_WOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOU_CHILDREN),
     value: Some(&["would"]),
 };
 
-pub static WORD_WOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dl"),
@@ -1258,12 +1258,12 @@ pub static WORD_WOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_WOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOT_CHILDREN),
+static WORD_WOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hout"),
@@ -1283,12 +1283,12 @@ pub static WORD_WOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WOR_CHILDREN),
+static WORD_WOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WOR_CHILDREN),
     value: None,
 };
 
-static WORD_WOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WORA_NODE),
     Some(&WORD_WORB_NODE),
     Some(&WORD_WORC_NODE),
@@ -1317,12 +1317,12 @@ static WORD_WOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORT_CHILDREN),
+static WORD_WORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("helss"),
@@ -1338,12 +1338,12 @@ pub static WORD_WORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_WORS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORS_CHILDREN),
+static WORD_WORS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORS_CHILDREN),
     value: Some(&["wars", "was", "works", "worse", "worst"]),
 };
 
-pub static WORD_WORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("hippig"),
@@ -1367,12 +1367,12 @@ pub static WORD_WORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_WORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORR_CHILDREN),
+static WORD_WORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -1381,12 +1381,12 @@ pub static WORD_WORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_WORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORN_CHILDREN),
+static WORD_WORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -1396,23 +1396,23 @@ pub static WORD_WORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_WORM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORM_CHILDREN),
+static WORD_WORM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORM_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arounds")],
     values: &[&["workarounds"]],
     range: 7..=7,
 };
 
-static WORD_WORL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORL_CHILDREN),
+static WORD_WORL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORL_CHILDREN),
     value: Some(&["world"]),
 };
 
-pub static WORD_WORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("divew"),
         dictgen::InsensitiveStr::Ascii("dveiw"),
@@ -1430,12 +1430,12 @@ pub static WORD_WORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_WORK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WORK_CHILDREN),
+static WORD_WORK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WORK_CHILDREN),
     value: None,
 };
 
-static WORD_WORK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WORK_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WORKA_NODE),
     Some(&WORD_WORKB_NODE),
     None,
@@ -1464,23 +1464,23 @@ static WORD_WORK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WORKW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKW_CHILDREN),
+static WORD_WORKW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKW_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("round")],
     values: &[&["workaround"]],
     range: 5..=5,
 };
 
-static WORD_WORKS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKS_CHILDREN),
+static WORD_WORKS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("apce"),
@@ -1520,12 +1520,12 @@ pub static WORD_WORKS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_WORKR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKR_CHILDREN),
+static WORD_WORKR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ound"),
         dictgen::InsensitiveStr::Ascii("ounds"),
@@ -1534,12 +1534,12 @@ pub static WORD_WORKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_WORKP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKP_CHILDREN),
+static WORD_WORKP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("sace"),
@@ -1549,12 +1549,12 @@ pub static WORD_WORKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_WORKL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKL_CHILDREN),
+static WORD_WORKL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fow"),
         dictgen::InsensitiveStr::Ascii("fows"),
@@ -1564,12 +1564,12 @@ pub static WORD_WORKL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_WORKI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKI_CHILDREN),
+static WORD_WORKI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gn"),
@@ -1587,12 +1587,12 @@ pub static WORD_WORKI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_WORKF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKF_CHILDREN),
+static WORD_WORKF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKF_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("around"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -1610,12 +1610,12 @@ pub static WORD_WORKF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_WORKE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKE_CHILDREN),
+static WORD_WORKE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKE_CHILDREN),
     value: Some(&["work", "worked", "works"]),
 };
 
-pub static WORD_WORKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nch"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -1624,23 +1624,23 @@ pub static WORD_WORKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_WORKD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKD_CHILDREN),
+static WORD_WORKD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKD_CHILDREN),
     value: Some(&["worked", "works"]),
 };
 
-pub static WORD_WORKD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pace")],
     values: &[&["workspace"]],
     range: 4..=4,
 };
 
-static WORD_WORKB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKB_CHILDREN),
+static WORD_WORKB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKB_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anch"),
         dictgen::InsensitiveStr::Ascii("anches"),
@@ -1668,12 +1668,12 @@ pub static WORD_WORKB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_WORKA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKA_CHILDREN),
+static WORD_WORKA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orund"),
         dictgen::InsensitiveStr::Ascii("orunds"),
@@ -1727,23 +1727,23 @@ pub static WORD_WORKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_WORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORI_CHILDREN),
+static WORD_WORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["working"]],
     range: 2..=2,
 };
 
-static WORD_WORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORH_CHILDREN),
+static WORD_WORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("siping"),
         dictgen::InsensitiveStr::Ascii("sipping"),
@@ -1759,12 +1759,12 @@ pub static WORD_WORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_WORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORF_CHILDREN),
+static WORD_WORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("klow"),
         dictgen::InsensitiveStr::Ascii("klows"),
@@ -1775,12 +1775,12 @@ pub static WORD_WORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_WORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORD_CHILDREN),
+static WORD_WORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lview"),
@@ -1798,23 +1798,23 @@ pub static WORD_WORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_WORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORC_CHILDREN),
+static WORD_WORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hester")],
     values: &[&["worcester"]],
     range: 6..=6,
 };
 
-static WORD_WORB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORB_CHILDREN),
+static WORD_WORB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORB_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ench"),
         dictgen::InsensitiveStr::Ascii("enches"),
@@ -1823,12 +1823,12 @@ pub static WORD_WORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_WORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORA_CHILDREN),
+static WORD_WORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("round"),
         dictgen::InsensitiveStr::Ascii("rounds"),
@@ -1837,12 +1837,12 @@ pub static WORD_WORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_WOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOO_CHILDREN),
+static WORD_WOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dowrking"),
         dictgen::InsensitiveStr::Ascii("dworkign"),
@@ -1852,12 +1852,12 @@ pub static WORD_WOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_WON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WON_CHILDREN),
+static WORD_WON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WON_CHILDREN),
     value: None,
 };
 
-pub static WORD_WON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("deful"),
@@ -1893,23 +1893,23 @@ pub static WORD_WON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_WOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOM_CHILDREN),
+static WORD_WOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ens")],
     values: &[&["women"]],
     range: 3..=3,
 };
 
-static WORD_WOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOL_CHILDREN),
+static WORD_WOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ffram"),
         dictgen::InsensitiveStr::Ascii("low"),
@@ -1933,12 +1933,12 @@ pub static WORD_WOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_WOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOK_CHILDREN),
+static WORD_WOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ring"),
@@ -1949,12 +1949,12 @@ pub static WORD_WOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOI_CHILDREN),
+static WORD_WOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -1966,34 +1966,34 @@ pub static WORD_WOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_WOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOH_CHILDREN),
+static WORD_WOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOH_CHILDREN),
     value: Some(&["who"]),
 };
 
-pub static WORD_WOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["whole"]],
     range: 2..=2,
 };
 
-static WORD_WOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOA_CHILDREN),
+static WORD_WOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rkaround")],
     values: &[&["workaround"]],
     range: 8..=8,
 };
 
-static WORD_WN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WN_CHILDREN),
+static WORD_WN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -2019,23 +2019,23 @@ pub static WORD_WN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WM_CHILDREN),
+static WORD_WM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WM_CHILDREN),
     value: None,
 };
 
-pub static WORD_WM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pty")],
     values: &[&["empty"]],
     range: 3..=3,
 };
 
-static WORD_WL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WL_CHILDREN),
+static WORD_WL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acott"),
         dictgen::InsensitiveStr::Ascii("aking"),
@@ -2046,23 +2046,23 @@ pub static WORD_WL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WJ_CHILDREN),
+static WORD_WJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_WJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("at")],
     values: &[&["what"]],
     range: 2..=2,
 };
 
-static WORD_WI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WI_CHILDREN),
+static WORD_WI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WI_CHILDREN),
     value: None,
 };
 
-static WORD_WI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WIA_NODE),
     None,
     Some(&WORD_WIC_NODE),
@@ -2091,23 +2091,23 @@ static WORD_WI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_WIZ_NODE),
 ];
 
-static WORD_WIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIZ_CHILDREN),
+static WORD_WIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("zard")],
     values: &[&["wizard"]],
     range: 4..=4,
 };
 
-static WORD_WIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIY_CHILDREN),
+static WORD_WIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hout"),
@@ -2117,23 +2117,23 @@ pub static WORD_WIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIU_CHILDREN),
+static WORD_WIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ll")],
     values: &[&["will"]],
     range: 2..=2,
 };
 
-static WORD_WIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WIT_CHILDREN),
+static WORD_WIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WIT_CHILDREN),
     value: None,
 };
 
-static WORD_WIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WIT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WITA_NODE),
     None,
     None,
@@ -2162,45 +2162,45 @@ static WORD_WIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WITT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITT_CHILDREN),
+static WORD_WITT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["with"]],
     range: 1..=1,
 };
 
-static WORD_WITR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITR_CHILDREN),
+static WORD_WITR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["with"]],
     range: 1..=1,
 };
 
-static WORD_WITO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITO_CHILDREN),
+static WORD_WITO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ut")],
     values: &[&["without"]],
     range: 2..=2,
 };
 
-static WORD_WITN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITN_CHILDREN),
+static WORD_WITN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITN_CHILDREN),
     value: Some(&["with"]),
 };
 
-pub static WORD_WITN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esess"),
         dictgen::InsensitiveStr::Ascii("esss"),
@@ -2216,34 +2216,34 @@ pub static WORD_WITN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_WITK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITK_CHILDREN),
+static WORD_WITK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITK_CHILDREN),
     value: Some(&["with"]),
 };
 
-pub static WORD_WITK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_WITI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITI_CHILDREN),
+static WORD_WITI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("n")],
     values: &[&["within"]],
     range: 1..=1,
 };
 
-static WORD_WITH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITH_CHILDREN),
+static WORD_WITH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -2355,23 +2355,23 @@ pub static WORD_WITH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_WITE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITE_CHILDREN),
+static WORD_WITE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITE_CHILDREN),
     value: Some(&["write", "white"]),
 };
 
-pub static WORD_WITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_WITD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITD_CHILDREN),
+static WORD_WITD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITD_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hs"),
@@ -2382,23 +2382,23 @@ pub static WORD_WITD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_WITA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITA_CHILDREN),
+static WORD_WITA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ble")],
     values: &[&["writeable"]],
     range: 3..=3,
 };
 
-static WORD_WIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIS_CHILDREN),
+static WORD_WIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cle"),
         dictgen::InsensitiveStr::Ascii("cled"),
@@ -2448,12 +2448,12 @@ pub static WORD_WIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_WIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIR_CHILDREN),
+static WORD_WIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("edest"),
@@ -2495,34 +2495,34 @@ pub static WORD_WIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_WIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIP_CHILDREN),
+static WORD_WIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oing")],
     values: &[&["wiping"]],
     range: 4..=4,
 };
 
-static WORD_WIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIO_CHILDREN),
+static WORD_WIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("th")],
     values: &[&["with"]],
     range: 2..=2,
 };
 
-static WORD_WIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIN_CHILDREN),
+static WORD_WIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cheseter"),
         dictgen::InsensitiveStr::Ascii("chestor"),
@@ -2594,12 +2594,12 @@ pub static WORD_WIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIM_CHILDREN),
+static WORD_WIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("men"),
         dictgen::InsensitiveStr::Ascii("menly"),
@@ -2609,12 +2609,12 @@ pub static WORD_WIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_WIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIL_CHILDREN),
+static WORD_WIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIL_CHILDREN),
     value: Some(&["will", "well"]),
 };
 
-pub static WORD_WIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("card"),
         dictgen::InsensitiveStr::Ascii("cards"),
@@ -2652,12 +2652,12 @@ pub static WORD_WIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIK_CHILDREN),
+static WORD_WIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ileakers"),
         dictgen::InsensitiveStr::Ascii("ileakes"),
@@ -2667,12 +2667,12 @@ pub static WORD_WIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_WII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WII_CHILDREN),
+static WORD_WII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WII_CHILDREN),
     value: None,
 };
 
-pub static WORD_WII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -2682,12 +2682,12 @@ pub static WORD_WII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_WIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIH_CHILDREN),
+static WORD_WIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIH_CHILDREN),
     value: Some(&["with"]),
 };
 
-pub static WORD_WIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ich"),
@@ -2711,12 +2711,12 @@ pub static WORD_WIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIG_CHILDREN),
+static WORD_WIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("det"),
         dictgen::InsensitiveStr::Ascii("dets"),
@@ -2732,12 +2732,12 @@ pub static WORD_WIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_WIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIE_CHILDREN),
+static WORD_WIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("ghed"),
@@ -2769,12 +2769,12 @@ pub static WORD_WIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_WID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WID_CHILDREN),
+static WORD_WID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WID_CHILDREN),
     value: None,
 };
 
-pub static WORD_WID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("epsread"),
@@ -2820,12 +2820,12 @@ pub static WORD_WID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_WIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIC_CHILDREN),
+static WORD_WIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -2834,12 +2834,12 @@ pub static WORD_WIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=1,
 };
 
-static WORD_WIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIA_CHILDREN),
+static WORD_WIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ters"),
@@ -2850,12 +2850,12 @@ pub static WORD_WIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WH_CHILDREN),
+static WORD_WH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WH_CHILDREN),
     value: None,
 };
 
-static WORD_WH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WHA_NODE),
     None,
     Some(&WORD_WHC_NODE),
@@ -2884,12 +2884,12 @@ static WORD_WH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHY_CHILDREN),
+static WORD_WHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("th"),
@@ -2899,23 +2899,23 @@ pub static WORD_WHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHU_CHILDREN),
+static WORD_WHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["while", "whole"]],
     range: 2..=2,
 };
 
-static WORD_WHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHT_CHILDREN),
+static WORD_WHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHT_CHILDREN),
     value: Some(&["what"]),
 };
 
-pub static WORD_WHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("her"),
@@ -2926,12 +2926,12 @@ pub static WORD_WHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WHS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHS_CHILDREN),
+static WORD_WHS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iper"),
         dictgen::InsensitiveStr::Ascii("ipered"),
@@ -2942,12 +2942,12 @@ pub static WORD_WHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_WHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHR_CHILDREN),
+static WORD_WHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ilwind"),
@@ -2956,12 +2956,12 @@ pub static WORD_WHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHO_CHILDREN),
+static WORD_WHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -2999,23 +2999,23 @@ pub static WORD_WHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_WHN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHN_CHILDREN),
+static WORD_WHN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHN_CHILDREN),
     value: Some(&["when"]),
 };
 
-pub static WORD_WHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["when"]],
     range: 1..=1,
 };
 
-static WORD_WHL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHL_CHILDREN),
+static WORD_WHL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -3025,12 +3025,12 @@ pub static WORD_WHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_WHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHI_CHILDREN),
+static WORD_WHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cg"),
@@ -3158,12 +3158,12 @@ pub static WORD_WHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_WHH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHH_CHILDREN),
+static WORD_WHH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eel"),
         dictgen::InsensitiveStr::Ascii("en"),
@@ -3172,12 +3172,12 @@ pub static WORD_WHH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_WHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHE_CHILDREN),
+static WORD_WHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHE_CHILDREN),
     value: Some(&["when", "we"]),
 };
 
-pub static WORD_WHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ater"),
         dictgen::InsensitiveStr::Ascii("ather"),
@@ -3237,12 +3237,12 @@ pub static WORD_WHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WHC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHC_CHILDREN),
+static WORD_WHC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("ich"),
@@ -3252,12 +3252,12 @@ pub static WORD_WHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_WHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHA_CHILDREN),
+static WORD_WHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHA_CHILDREN),
     value: Some(&["what"]),
 };
 
-pub static WORD_WHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("eton"),
@@ -3297,12 +3297,12 @@ pub static WORD_WHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WE_CHILDREN),
+static WORD_WE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WE_CHILDREN),
     value: None,
 };
 
-static WORD_WE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WEA_NODE),
     Some(&WORD_WEB_NODE),
     None,
@@ -3331,12 +3331,12 @@ static WORD_WE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_WEZ_NODE),
 ];
 
-static WORD_WEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEZ_CHILDREN),
+static WORD_WEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("zal"),
         dictgen::InsensitiveStr::Ascii("zals"),
@@ -3345,34 +3345,34 @@ pub static WORD_WEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_WEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEW_CHILDREN),
+static WORD_WEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEW_CHILDREN),
     value: Some(&["we"]),
 };
 
-pub static WORD_WEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_WET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WET_CHILDREN),
+static WORD_WET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WET_CHILDREN),
     value: None,
 };
 
-pub static WORD_WET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("her")],
     values: &[&["weather", "whether"]],
     range: 3..=3,
 };
 
-static WORD_WES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WES_CHILDREN),
+static WORD_WES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WES_CHILDREN),
     value: None,
 };
 
-pub static WORD_WES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bite"),
         dictgen::InsensitiveStr::Ascii("bites"),
@@ -3416,12 +3416,12 @@ pub static WORD_WES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_WER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WER_CHILDREN),
+static WORD_WER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WER_CHILDREN),
     value: None,
 };
 
-pub static WORD_WER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eabouts"),
         dictgen::InsensitiveStr::Ascii("eas"),
@@ -3451,12 +3451,12 @@ pub static WORD_WER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_WEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEP_CHILDREN),
+static WORD_WEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bage"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -3474,12 +3474,12 @@ pub static WORD_WEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_WEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEN_CHILDREN),
+static WORD_WEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("desday"),
         dictgen::InsensitiveStr::Ascii("desdays"),
@@ -3497,12 +3497,12 @@ pub static WORD_WEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_WEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEL_CHILDREN),
+static WORD_WEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEL_CHILDREN),
     value: Some(&["well"]),
 };
 
-pub static WORD_WEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("athier"),
         dictgen::InsensitiveStr::Ascii("athiest"),
@@ -3532,12 +3532,12 @@ pub static WORD_WEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEK_CHILDREN),
+static WORD_WEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("eend"),
@@ -3548,12 +3548,12 @@ pub static WORD_WEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEI_CHILDREN),
+static WORD_WEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghtened"),
         dictgen::InsensitiveStr::Ascii("ghtlfiting"),
@@ -3597,12 +3597,12 @@ pub static WORD_WEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_WEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEH_CHILDREN),
+static WORD_WEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ere"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -3613,23 +3613,23 @@ pub static WORD_WEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEG_CHILDREN),
+static WORD_WEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["wedge"]],
     range: 1..=1,
 };
 
-static WORD_WEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEE_CHILDREN),
+static WORD_WEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ek"),
         dictgen::InsensitiveStr::Ascii("ekend"),
@@ -3663,12 +3663,12 @@ pub static WORD_WEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WED_CHILDREN),
+static WORD_WED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WED_CHILDREN),
     value: None,
 };
 
-pub static WORD_WED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eged"),
         dictgen::InsensitiveStr::Ascii("ensday"),
@@ -3704,12 +3704,12 @@ pub static WORD_WED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_WEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEB_CHILDREN),
+static WORD_WEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("apge"),
@@ -3737,12 +3737,12 @@ pub static WORD_WEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_WEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEA_CHILDREN),
+static WORD_WEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hter"),
         dictgen::InsensitiveStr::Ascii("hters"),
@@ -3782,23 +3782,23 @@ pub static WORD_WEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WD_CHILDREN),
+static WORD_WD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WD_CHILDREN),
     value: None,
 };
 
-pub static WORD_WD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("th")],
     values: &[&["width"]],
     range: 2..=2,
 };
 
-static WORD_WA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WA_CHILDREN),
+static WORD_WA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WA_CHILDREN),
     value: None,
 };
 
-static WORD_WA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WAA_NODE),
     None,
     Some(&WORD_WAC_NODE),
@@ -3827,12 +3827,12 @@ static WORD_WA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAY_CHILDREN),
+static WORD_WAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ferer"),
         dictgen::InsensitiveStr::Ascii("oint"),
@@ -3843,12 +3843,12 @@ pub static WORD_WAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_WAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAW_CHILDREN),
+static WORD_WAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -3858,12 +3858,12 @@ pub static WORD_WAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAV_CHILDREN),
+static WORD_WAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elegnth"),
         dictgen::InsensitiveStr::Ascii("elegnths"),
@@ -3891,12 +3891,12 @@ pub static WORD_WAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_WAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAT_CHILDREN),
+static WORD_WAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chdong"),
         dictgen::InsensitiveStr::Ascii("chemn"),
@@ -3954,12 +3954,12 @@ pub static WORD_WAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAS_CHILDREN),
+static WORD_WAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hignton"),
         dictgen::InsensitiveStr::Ascii("hingtion"),
@@ -3977,12 +3977,12 @@ pub static WORD_WAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_WAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WAR_CHILDREN),
+static WORD_WAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WAR_CHILDREN),
     value: None,
 };
 
-static WORD_WAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WARA_NODE),
     None,
     Some(&WORD_WARC_NODE),
@@ -4011,34 +4011,34 @@ static WORD_WAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WARW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARW_CHILDREN),
+static WORD_WARW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARW_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cik")],
     values: &[&["warwick"]],
     range: 3..=3,
 };
 
-static WORD_WARU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARU_CHILDREN),
+static WORD_WARU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARU_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mup")],
     values: &[&["warmup"]],
     range: 3..=3,
 };
 
-static WORD_WARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARR_CHILDREN),
+static WORD_WARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andyte"),
         dictgen::InsensitiveStr::Ascii("ante"),
@@ -4078,12 +4078,12 @@ pub static WORD_WARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_WARP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARP_CHILDREN),
+static WORD_WARP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ped"),
         dictgen::InsensitiveStr::Ascii("per"),
@@ -4107,12 +4107,12 @@ pub static WORD_WARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_WARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARN_CHILDREN),
+static WORD_WARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibg"),
         dictgen::InsensitiveStr::Ascii("ibgs"),
@@ -4178,34 +4178,34 @@ pub static WORD_WARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_WARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARL_CHILDREN),
+static WORD_WARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("king")],
     values: &[&["walking"]],
     range: 4..=4,
 };
 
-static WORD_WARK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARK_CHILDREN),
+static WORD_WARK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["works"]],
     range: 1..=1,
 };
 
-static WORD_WARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARI_CHILDREN),
+static WORD_WARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("ngs"),
@@ -4231,23 +4231,23 @@ pub static WORD_WARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_WARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARD_CHILDREN),
+static WORD_WARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("obe")],
     values: &[&["wardrobe"]],
     range: 3..=3,
 };
 
-static WORD_WARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARC_CHILDREN),
+static WORD_WARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arft"),
         dictgen::InsensitiveStr::Ascii("rat"),
@@ -4256,12 +4256,12 @@ pub static WORD_WARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_WARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARA_CHILDREN),
+static WORD_WARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntee"),
         dictgen::InsensitiveStr::Ascii("nties"),
@@ -4271,23 +4271,23 @@ pub static WORD_WARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_WAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAP_CHILDREN),
+static WORD_WAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pers")],
     values: &[&["wrappers"]],
     range: 4..=4,
 };
 
-static WORD_WAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAN_CHILDREN),
+static WORD_WAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sts"),
         dictgen::InsensitiveStr::Ascii("td"),
@@ -4296,12 +4296,12 @@ pub static WORD_WAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_WAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAL_CHILDREN),
+static WORD_WAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kalbe"),
         dictgen::InsensitiveStr::Ascii("karound"),
@@ -4323,12 +4323,12 @@ pub static WORD_WAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_WAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAK_CHILDREN),
+static WORD_WAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eus"),
         dictgen::InsensitiveStr::Ascii("through"),
@@ -4344,12 +4344,12 @@ pub static WORD_WAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_WAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAI_CHILDREN),
+static WORD_WAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itng"),
         dictgen::InsensitiveStr::Ascii("nting"),
@@ -4373,12 +4373,12 @@ pub static WORD_WAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_WAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAH_CHILDREN),
+static WORD_WAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tever"),
@@ -4388,12 +4388,12 @@ pub static WORD_WAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAC_CHILDREN),
+static WORD_WAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hdog"),
         dictgen::InsensitiveStr::Ascii("lott"),
@@ -4403,23 +4403,23 @@ pub static WORD_WAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_WAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAA_CHILDREN),
+static WORD_WAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["was"]],
     range: 1..=1,
 };
 
-static WORD_V_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_V_CHILDREN),
+static WORD_V_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_V_CHILDREN),
     value: None,
 };
 
-static WORD_V_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_V_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VA_NODE),
     Some(&WORD_VB_NODE),
     None,
@@ -4448,12 +4448,12 @@ static WORD_V_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VY_CHILDREN),
+static WORD_VY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -4462,23 +4462,23 @@ pub static WORD_VY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_VV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VV_CHILDREN),
+static WORD_VV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VV_CHILDREN),
     value: None,
 };
 
-pub static WORD_VV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iew")],
     values: &[&["view"]],
     range: 3..=3,
 };
 
-static WORD_VU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VU_CHILDREN),
+static WORD_VU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VU_CHILDREN),
     value: None,
 };
 
-static WORD_VU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -4507,12 +4507,12 @@ static WORD_VU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VUR_CHILDREN),
+static WORD_VUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nerabilities"),
         dictgen::InsensitiveStr::Ascii("nerability"),
@@ -4521,12 +4521,12 @@ pub static WORD_VUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 10..=12,
 };
 
-static WORD_VUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VUN_CHILDREN),
+static WORD_VUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erabilities"),
         dictgen::InsensitiveStr::Ascii("erability"),
@@ -4552,12 +4552,12 @@ pub static WORD_VUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=12,
 };
 
-static WORD_VUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VUL_CHILDREN),
+static WORD_VUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VUL_CHILDREN),
     value: None,
 };
 
-static WORD_VUL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VUL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VULA_NODE),
     Some(&WORD_VULB_NODE),
     None,
@@ -4586,12 +4586,12 @@ static WORD_VUL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VULN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VULN_CHILDREN),
+static WORD_VULN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VULN_CHILDREN),
     value: None,
 };
 
-static WORD_VULN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VULN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VULNA_NODE),
     None,
     None,
@@ -4620,12 +4620,12 @@ static WORD_VULN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VULNU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULNU_CHILDREN),
+static WORD_VULNU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULNU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULNU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rabilities"),
         dictgen::InsensitiveStr::Ascii("rability"),
@@ -4635,12 +4635,12 @@ pub static WORD_VULNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_VULNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULNR_CHILDREN),
+static WORD_VULNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eabilities"),
         dictgen::InsensitiveStr::Ascii("eability"),
@@ -4649,12 +4649,12 @@ pub static WORD_VULNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_VULNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULNE_CHILDREN),
+static WORD_VULNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULNE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULNE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abilities"),
         dictgen::InsensitiveStr::Ascii("ability"),
@@ -4772,12 +4772,12 @@ pub static WORD_VULNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_VULND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULND_CHILDREN),
+static WORD_VULND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULND_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erabilities"),
         dictgen::InsensitiveStr::Ascii("erability"),
@@ -4786,12 +4786,12 @@ pub static WORD_VULND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=11,
 };
 
-static WORD_VULNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULNA_CHILDREN),
+static WORD_VULNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rabilities"),
         dictgen::InsensitiveStr::Ascii("rability"),
@@ -4801,12 +4801,12 @@ pub static WORD_VULNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_VULE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULE_CHILDREN),
+static WORD_VULE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nrability"),
         dictgen::InsensitiveStr::Ascii("rabilities"),
@@ -4834,12 +4834,12 @@ pub static WORD_VULE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_VULB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULB_CHILDREN),
+static WORD_VULB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earable"),
         dictgen::InsensitiveStr::Ascii("earabule"),
@@ -4919,12 +4919,12 @@ pub static WORD_VULB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=13,
 };
 
-static WORD_VULA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULA_CHILDREN),
+static WORD_VULA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cn"),
         dictgen::InsensitiveStr::Ascii("kn"),
@@ -4933,12 +4933,12 @@ pub static WORD_VULA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=2,
 };
 
-static WORD_VR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VR_CHILDREN),
+static WORD_VR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eity"),
         dictgen::InsensitiveStr::Ascii("esion"),
@@ -4992,12 +4992,12 @@ pub static WORD_VR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_VO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VO_CHILDREN),
+static WORD_VO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VO_CHILDREN),
     value: None,
 };
 
-static WORD_VO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_VOC_NODE),
@@ -5026,12 +5026,12 @@ static WORD_VO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOY_CHILDREN),
+static WORD_VOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("our"),
         dictgen::InsensitiveStr::Ascii("ouristic"),
@@ -5047,23 +5047,23 @@ pub static WORD_VOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_VOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOX_CHILDREN),
+static WORD_VOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["voxels", "voxel"]],
     range: 2..=2,
 };
 
-static WORD_VOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOU_CHILDREN),
+static WORD_VOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("me"),
@@ -5072,45 +5072,45 @@ pub static WORD_VOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_VOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOT_CHILDREN),
+static WORD_VOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lage")],
     values: &[&["voltage"]],
     range: 4..=4,
 };
 
-static WORD_VON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VON_CHILDREN),
+static WORD_VON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VON_CHILDREN),
     value: None,
 };
 
-pub static WORD_VON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fig")],
     values: &[&["config"]],
     range: 3..=3,
 };
 
-static WORD_VOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOM_CHILDREN),
+static WORD_VOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itting")],
     values: &[&["vomiting"]],
     range: 6..=6,
 };
 
-static WORD_VOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOL_CHILDREN),
+static WORD_VOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atage"),
         dictgen::InsensitiveStr::Ascii("atages"),
@@ -5232,12 +5232,12 @@ pub static WORD_VOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_VOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOI_CHILDREN),
+static WORD_VOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cemal"),
         dictgen::InsensitiveStr::Ascii("f"),
@@ -5259,12 +5259,12 @@ pub static WORD_VOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_VOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOC_CHILDREN),
+static WORD_VOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abluary"),
         dictgen::InsensitiveStr::Ascii("abularily"),
@@ -5282,12 +5282,12 @@ pub static WORD_VOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_VL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VL_CHILDREN),
+static WORD_VL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arge"),
         dictgen::InsensitiveStr::Ascii("aue"),
@@ -5309,12 +5309,12 @@ pub static WORD_VL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_VI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VI_CHILDREN),
+static WORD_VI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VI_CHILDREN),
     value: None,
 };
 
-static WORD_VI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VIA_NODE),
     Some(&WORD_VIB_NODE),
     Some(&WORD_VIC_NODE),
@@ -5343,12 +5343,12 @@ static WORD_VI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_VIZ_NODE),
 ];
 
-static WORD_VIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIZ_CHILDREN),
+static WORD_VIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ualisation"),
         dictgen::InsensitiveStr::Ascii("ualisations"),
@@ -5370,12 +5370,12 @@ pub static WORD_VIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=11,
 };
 
-static WORD_VIW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIW_CHILDREN),
+static WORD_VIW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIW_CHILDREN),
     value: Some(&["view"]),
 };
 
-pub static WORD_VIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -5395,12 +5395,12 @@ pub static WORD_VIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_VIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIU_CHILDREN),
+static WORD_VIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sally"),
         dictgen::InsensitiveStr::Ascii("sualisation"),
@@ -5409,12 +5409,12 @@ pub static WORD_VIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_VIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIT_CHILDREN),
+static WORD_VIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailty"),
         dictgen::InsensitiveStr::Ascii("aliy"),
@@ -5460,12 +5460,12 @@ pub static WORD_VIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_VIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VIS_CHILDREN),
+static WORD_VIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VIS_CHILDREN),
     value: None,
 };
 
-static WORD_VIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VIS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VISA_NODE),
     Some(&WORD_VISB_NODE),
     Some(&WORD_VISC_NODE),
@@ -5494,12 +5494,12 @@ static WORD_VIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VISU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISU_CHILDREN),
+static WORD_VISU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ab"),
         dictgen::InsensitiveStr::Ascii("abisation"),
@@ -5595,14 +5595,14 @@ pub static WORD_VISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_VIST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIST_CHILDREN),
+static WORD_VIST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIST_CHILDREN),
     value: Some(&[
         "visit", "fist", "gist", "list", "mist", "vast", "vest", "vista",
     ]),
 };
 
-pub static WORD_VIST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -5618,23 +5618,23 @@ pub static WORD_VIST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_VISS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISS_CHILDREN),
+static WORD_VISS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ible")],
     values: &[&["visible"]],
     range: 4..=4,
 };
 
-static WORD_VISI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISI_CHILDREN),
+static WORD_VISI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ably"),
@@ -5702,12 +5702,12 @@ pub static WORD_VISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_VISH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISH_CHILDREN),
+static WORD_VISH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISH_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eate"),
         dictgen::InsensitiveStr::Ascii("eation"),
@@ -5727,12 +5727,12 @@ pub static WORD_VISH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_VISE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISE_CHILDREN),
+static WORD_VISE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ral"),
         dictgen::InsensitiveStr::Ascii("rally"),
@@ -5742,23 +5742,23 @@ pub static WORD_VISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_VISC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISC_CHILDREN),
+static WORD_VISC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("real")],
     values: &[&["visceral"]],
     range: 4..=4,
 };
 
-static WORD_VISB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISB_CHILDREN),
+static WORD_VISB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ility"),
         dictgen::InsensitiveStr::Ascii("ily"),
@@ -5776,12 +5776,12 @@ pub static WORD_VISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_VISA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISA_CHILDREN),
+static WORD_VISA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -5791,12 +5791,12 @@ pub static WORD_VISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_VIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIR_CHILDREN),
+static WORD_VIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alence"),
         dictgen::InsensitiveStr::Ascii("alently"),
@@ -5908,12 +5908,12 @@ pub static WORD_VIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_VIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIO_CHILDREN),
+static WORD_VIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alte"),
         dictgen::InsensitiveStr::Ascii("alting"),
@@ -5945,12 +5945,12 @@ pub static WORD_VIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_VIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIN_CHILDREN),
+static WORD_VIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cinity"),
         dictgen::InsensitiveStr::Ascii("dicitve"),
@@ -5980,12 +5980,12 @@ pub static WORD_VIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_VIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIL_CHILDREN),
+static WORD_VIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igant"),
         dictgen::InsensitiveStr::Ascii("igante"),
@@ -6019,12 +6019,12 @@ pub static WORD_VIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_VIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIK_CHILDREN),
+static WORD_VIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igns"),
         dictgen::InsensitiveStr::Ascii("ingos"),
@@ -6033,12 +6033,12 @@ pub static WORD_VIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_VIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIG_CHILDREN),
+static WORD_VIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eur"),
         dictgen::InsensitiveStr::Ascii("ilane"),
@@ -6070,12 +6070,12 @@ pub static WORD_VIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_VIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIE_CHILDREN),
+static WORD_VIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("do"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -6125,12 +6125,12 @@ pub static WORD_VIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=15,
 };
 
-static WORD_VID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VID_CHILDREN),
+static WORD_VID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VID_CHILDREN),
     value: None,
 };
 
-pub static WORD_VID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eogaem"),
         dictgen::InsensitiveStr::Ascii("eogaems"),
@@ -6158,12 +6158,12 @@ pub static WORD_VID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_VIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIC_CHILDREN),
+static WORD_VIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("intiy"),
         dictgen::InsensitiveStr::Ascii("itmized"),
@@ -6235,12 +6235,12 @@ pub static WORD_VIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_VIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIB_CHILDREN),
+static WORD_VIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ratao"),
         dictgen::InsensitiveStr::Ascii("ratie"),
@@ -6258,12 +6258,12 @@ pub static WORD_VIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_VIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIA_CHILDREN),
+static WORD_VIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biliy"),
         dictgen::InsensitiveStr::Ascii("riable"),
@@ -6281,23 +6281,23 @@ pub static WORD_VIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_VH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VH_CHILDREN),
+static WORD_VH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VH_CHILDREN),
     value: None,
 };
 
-pub static WORD_VH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ild")],
     values: &[&["child"]],
     range: 3..=3,
 };
 
-static WORD_VE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VE_CHILDREN),
+static WORD_VE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VE_CHILDREN),
     value: None,
 };
 
-static WORD_VE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VEA_NODE),
     Some(&WORD_VEB_NODE),
     Some(&WORD_VEC_NODE),
@@ -6326,34 +6326,34 @@ static WORD_VE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEY_CHILDREN),
+static WORD_VEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEY_CHILDREN),
     value: Some(&["very"]),
 };
 
-pub static WORD_VEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["very"]],
     range: 1..=1,
 };
 
-static WORD_VEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEW_CHILDREN),
+static WORD_VEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEW_CHILDREN),
     value: Some(&["view"]),
 };
 
-pub static WORD_VEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iership")],
     values: &[&["viewership"]],
     range: 7..=7,
 };
 
-static WORD_VET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VET_CHILDREN),
+static WORD_VET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VET_CHILDREN),
     value: None,
 };
 
-pub static WORD_VET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ex"),
         dictgen::InsensitiveStr::Ascii("exes"),
@@ -6387,12 +6387,12 @@ pub static WORD_VET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_VES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VES_CHILDREN),
+static WORD_VES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VES_CHILDREN),
     value: None,
 };
 
-pub static WORD_VES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -6414,12 +6414,12 @@ pub static WORD_VES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_VER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VER_CHILDREN),
+static WORD_VER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VER_CHILDREN),
     value: None,
 };
 
-static WORD_VER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VERA_NODE),
     Some(&WORD_VERB_NODE),
     Some(&WORD_VERC_NODE),
@@ -6448,12 +6448,12 @@ static WORD_VER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERY_CHILDREN),
+static WORD_VERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fieng"),
         dictgen::InsensitiveStr::Ascii("fing"),
@@ -6481,23 +6481,23 @@ pub static WORD_VERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_VERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERU_CHILDREN),
+static WORD_VERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERU_CHILDREN),
     value: Some(&["very"]),
 };
 
-pub static WORD_VERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_VERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERT_CHILDREN),
+static WORD_VERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abim"),
         dictgen::InsensitiveStr::Ascii("abraes"),
@@ -6579,12 +6579,12 @@ pub static WORD_VERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_VERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERS_CHILDREN),
+static WORD_VERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alite"),
         dictgen::InsensitiveStr::Ascii("atality"),
@@ -6680,12 +6680,12 @@ pub static WORD_VERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_VERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERR_CHILDREN),
+static WORD_VERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -6695,12 +6695,12 @@ pub static WORD_VERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_VERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERN_CHILDREN),
+static WORD_VERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aculaire"),
         dictgen::InsensitiveStr::Ascii("dor"),
@@ -6716,12 +6716,12 @@ pub static WORD_VERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_VERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERM_CHILDREN),
+static WORD_VERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("uth"),
@@ -6730,23 +6730,23 @@ pub static WORD_VERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_VERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERL_CHILDREN),
+static WORD_VERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["very"]],
     range: 1..=1,
 };
 
-static WORD_VERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERI_CHILDREN),
+static WORD_VERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -6864,12 +6864,12 @@ pub static WORD_VERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_VERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERF_CHILDREN),
+static WORD_VERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("iciation"),
@@ -6915,12 +6915,12 @@ pub static WORD_VERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_VERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERE_CHILDREN),
+static WORD_VERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gated"),
         dictgen::InsensitiveStr::Ascii("igated"),
@@ -6938,12 +6938,12 @@ pub static WORD_VERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_VERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERC_CHILDREN),
+static WORD_VERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hew"),
         dictgen::InsensitiveStr::Ascii("hews"),
@@ -6954,12 +6954,12 @@ pub static WORD_VERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_VERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERB_CHILDREN),
+static WORD_VERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("aitm"),
@@ -6991,12 +6991,12 @@ pub static WORD_VERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_VERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERA_CHILDREN),
+static WORD_VERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blly"),
         dictgen::InsensitiveStr::Ascii("gated"),
@@ -7006,12 +7006,12 @@ pub static WORD_VERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_VEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEN_CHILDREN),
+static WORD_VEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deta"),
         dictgen::InsensitiveStr::Ascii("dettta"),
@@ -7071,12 +7071,12 @@ pub static WORD_VEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_VEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEL_CHILDREN),
+static WORD_VEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antine"),
         dictgen::InsensitiveStr::Ascii("city"),
@@ -7096,12 +7096,12 @@ pub static WORD_VEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_VEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEK_CHILDREN),
+static WORD_VEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tor"),
         dictgen::InsensitiveStr::Ascii("tors"),
@@ -7110,12 +7110,12 @@ pub static WORD_VEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_VEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEI_CHILDREN),
+static WORD_VEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chles"),
         dictgen::InsensitiveStr::Ascii("cle"),
@@ -7155,12 +7155,12 @@ pub static WORD_VEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_VEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEH_CHILDREN),
+static WORD_VEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cile"),
         dictgen::InsensitiveStr::Ascii("ciles"),
@@ -7188,12 +7188,12 @@ pub static WORD_VEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_VEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEG_CHILDREN),
+static WORD_VEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anisim"),
         dictgen::InsensitiveStr::Ascii("ansim"),
@@ -7261,34 +7261,34 @@ pub static WORD_VEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_VEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEF_CHILDREN),
+static WORD_VEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iry")],
     values: &[&["verify"]],
     range: 3..=3,
 };
 
-static WORD_VED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VED_CHILDREN),
+static WORD_VED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VED_CHILDREN),
     value: None,
 };
 
-pub static WORD_VED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("io")],
     values: &[&["video"]],
     range: 2..=2,
 };
 
-static WORD_VEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEC_CHILDREN),
+static WORD_VEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hicle"),
         dictgen::InsensitiveStr::Ascii("hile"),
@@ -7332,23 +7332,23 @@ pub static WORD_VEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_VEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEB_CHILDREN),
+static WORD_VEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rose")],
     values: &[&["verbose"]],
     range: 4..=4,
 };
 
-static WORD_VEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEA_CHILDREN),
+static WORD_VEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mant"),
         dictgen::InsensitiveStr::Ascii("mantly"),
@@ -7358,23 +7358,23 @@ pub static WORD_VEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_VB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VB_CHILDREN),
+static WORD_VB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("srcript")],
     values: &[&["vbscript"]],
     range: 7..=7,
 };
 
-static WORD_VA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VA_CHILDREN),
+static WORD_VA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VA_CHILDREN),
     value: None,
 };
 
-static WORD_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VAA_NODE),
     None,
     Some(&WORD_VAC_NODE),
@@ -7403,23 +7403,23 @@ static WORD_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAY_CHILDREN),
+static WORD_VAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lkrie")],
     values: &[&["valkyrie"]],
     range: 5..=5,
 };
 
-static WORD_VAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAW_CHILDREN),
+static WORD_VAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dville"),
         dictgen::InsensitiveStr::Ascii("dvillean"),
@@ -7429,12 +7429,12 @@ pub static WORD_VAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=8,
 };
 
-static WORD_VAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAV_CHILDREN),
+static WORD_VAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("le"),
@@ -7452,12 +7452,12 @@ pub static WORD_VAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_VAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAU_CHILDREN),
+static WORD_VAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -7485,12 +7485,12 @@ pub static WORD_VAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_VAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAT_CHILDREN),
+static WORD_VAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icaan"),
         dictgen::InsensitiveStr::Ascii("icina"),
@@ -7499,12 +7499,12 @@ pub static WORD_VAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_VAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAS_CHILDREN),
+static WORD_VAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAS_CHILDREN),
     value: Some(&["was"]),
 };
 
-pub static WORD_VAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("alls"),
@@ -7530,12 +7530,12 @@ pub static WORD_VAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_VAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VAR_CHILDREN),
+static WORD_VAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VAR_CHILDREN),
     value: None,
 };
 
-static WORD_VAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VARA_NODE),
     None,
     None,
@@ -7564,12 +7564,12 @@ static WORD_VAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VART_CHILDREN),
+static WORD_VART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VART_CHILDREN),
     value: Some(&["cart", "wart"]),
 };
 
-pub static WORD_VART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ex"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -7587,23 +7587,23 @@ pub static WORD_VART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_VARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARS_CHILDREN),
+static WORD_VARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tiy")],
     values: &[&["varsity"]],
     range: 3..=3,
 };
 
-static WORD_VARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARR_CHILDREN),
+static WORD_VARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iance"),
         dictgen::InsensitiveStr::Ascii("iances"),
@@ -7612,12 +7612,12 @@ pub static WORD_VARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_VARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARO_CHILDREN),
+static WORD_VARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ius"),
         dictgen::InsensitiveStr::Ascii("us"),
@@ -7627,12 +7627,12 @@ pub static WORD_VARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_VARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARN_CHILDREN),
+static WORD_VARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARN_CHILDREN),
     value: Some(&["warn"]),
 };
 
-pub static WORD_VARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -7643,12 +7643,12 @@ pub static WORD_VARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_VARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARM_CHILDREN),
+static WORD_VARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("its"),
@@ -7657,12 +7657,12 @@ pub static WORD_VARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_VARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VARI_CHILDREN),
+static WORD_VARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VARI_CHILDREN),
     value: None,
 };
 
-static WORD_VARI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VARI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VARIA_NODE),
     Some(&WORD_VARIB_NODE),
     None,
@@ -7691,12 +7691,12 @@ static WORD_VARI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VARIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIU_CHILDREN),
+static WORD_VARIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("os"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -7706,12 +7706,12 @@ pub static WORD_VARIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_VARIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIT_CHILDREN),
+static WORD_VARIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ey"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -7721,23 +7721,23 @@ pub static WORD_VARIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_VARIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIS_CHILDREN),
+static WORD_VARIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ty")],
     values: &[&["varsity"]],
     range: 2..=2,
 };
 
-static WORD_VARIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIN_CHILDREN),
+static WORD_VARIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ats"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -7746,12 +7746,12 @@ pub static WORD_VARIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_VARIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIL_CHILDREN),
+static WORD_VARIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ue"),
         dictgen::InsensitiveStr::Ascii("ues"),
@@ -7760,34 +7760,34 @@ pub static WORD_VARIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_VARII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARII_CHILDREN),
+static WORD_VARII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARII_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["varying"]],
     range: 2..=2,
 };
 
-static WORD_VARIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIG_CHILDREN),
+static WORD_VARIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ated")],
     values: &[&["variegated"]],
     range: 4..=4,
 };
 
-static WORD_VARIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIF_CHILDREN),
+static WORD_VARIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -7807,12 +7807,12 @@ pub static WORD_VARIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_VARIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIE_CHILDREN),
+static WORD_VARIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -7836,12 +7836,12 @@ pub static WORD_VARIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_VARIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIB_CHILDREN),
+static WORD_VARIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -7873,12 +7873,12 @@ pub static WORD_VARIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_VARIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIA_CHILDREN),
+static WORD_VARIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bble"),
         dictgen::InsensitiveStr::Ascii("bbles"),
@@ -7950,12 +7950,12 @@ pub static WORD_VARIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_VARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARE_CHILDREN),
+static WORD_VARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gated"),
         dictgen::InsensitiveStr::Ascii("igated"),
@@ -7965,12 +7965,12 @@ pub static WORD_VARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_VARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARA_CHILDREN),
+static WORD_VARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bles"),
@@ -8004,12 +8004,12 @@ pub static WORD_VARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_VAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAN_CHILDREN),
+static WORD_VAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adlism"),
         dictgen::InsensitiveStr::Ascii("dalisim"),
@@ -8035,12 +8035,12 @@ pub static WORD_VAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_VAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAM_CHILDREN),
+static WORD_VAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipres"),
         dictgen::InsensitiveStr::Ascii("piers"),
@@ -8051,12 +8051,12 @@ pub static WORD_VAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_VAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VAL_CHILDREN),
+static WORD_VAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VAL_CHILDREN),
     value: None,
 };
 
-static WORD_VAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VALA_NODE),
     None,
     None,
@@ -8085,12 +8085,12 @@ static WORD_VAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALY_CHILDREN),
+static WORD_VALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("krie"),
@@ -8099,12 +8099,12 @@ pub static WORD_VALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_VALU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALU_CHILDREN),
+static WORD_VALU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALU_CHILDREN),
     value: Some(&["value"]),
 };
 
-pub static WORD_VALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("bale"),
@@ -8144,12 +8144,12 @@ pub static WORD_VALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_VALT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALT_CHILDREN),
+static WORD_VALT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -8158,23 +8158,23 @@ pub static WORD_VALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_VALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALS_CHILDREN),
+static WORD_VALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ues")],
     values: &[&["values"]],
     range: 3..=3,
 };
 
-static WORD_VALN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALN_CHILDREN),
+static WORD_VALN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecia"),
         dictgen::InsensitiveStr::Ascii("etines"),
@@ -8183,12 +8183,12 @@ pub static WORD_VALN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_VALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALL_CHILDREN),
+static WORD_VALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ayed"),
@@ -8222,12 +8222,12 @@ pub static WORD_VALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_VALK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALK_CHILDREN),
+static WORD_VALK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALK_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irye"),
         dictgen::InsensitiveStr::Ascii("iyre"),
@@ -8249,12 +8249,12 @@ pub static WORD_VALK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_VALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALI_CHILDREN),
+static WORD_VALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ator"),
@@ -8318,12 +8318,12 @@ pub static WORD_VALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_VALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALE_CHILDREN),
+static WORD_VALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nca"),
         dictgen::InsensitiveStr::Ascii("nica"),
@@ -8361,12 +8361,12 @@ pub static WORD_VALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_VALD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALD_CHILDREN),
+static WORD_VALD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALD_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -8376,23 +8376,23 @@ pub static WORD_VALD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_VALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALA_CHILDREN),
+static WORD_VALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ilable")],
     values: &[&["available"]],
     range: 6..=6,
 };
 
-static WORD_VAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAK_CHILDREN),
+static WORD_VAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lyrie"),
         dictgen::InsensitiveStr::Ascii("ue"),
@@ -8403,12 +8403,12 @@ pub static WORD_VAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_VAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAI_CHILDREN),
+static WORD_VAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAI_CHILDREN),
     value: Some(&["via", "vie"]),
 };
 
-pub static WORD_VAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -8452,12 +8452,12 @@ pub static WORD_VAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_VAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAG_CHILDREN),
+static WORD_VAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euly"),
         dictgen::InsensitiveStr::Ascii("uaries"),
@@ -8468,12 +8468,12 @@ pub static WORD_VAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_VAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAE_CHILDREN),
+static WORD_VAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lue"),
         dictgen::InsensitiveStr::Ascii("lues"),
@@ -8482,12 +8482,12 @@ pub static WORD_VAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_VAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAC_CHILDREN),
+static WORD_VAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciante"),
         dictgen::InsensitiveStr::Ascii("ciantion"),
@@ -8565,23 +8565,23 @@ pub static WORD_VAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_VAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAA_CHILDREN),
+static WORD_VAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lues")],
     values: &[&["values"]],
     range: 4..=4,
 };
 
-static WORD_U_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_U_CHILDREN),
+static WORD_U_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_U_CHILDREN),
     value: None,
 };
 
-static WORD_U_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_U_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_UB_NODE),
     Some(&WORD_UC_NODE),
@@ -8610,23 +8610,23 @@ static WORD_U_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UY_CHILDREN),
+static WORD_UY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UY_CHILDREN),
     value: None,
 };
 
-pub static WORD_UY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ou")],
     values: &[&["you"]],
     range: 2..=2,
 };
 
-static WORD_UU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UU_CHILDREN),
+static WORD_UU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pload"),
         dictgen::InsensitiveStr::Ascii("pper"),
@@ -8635,12 +8635,12 @@ pub static WORD_UU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_UT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UT_CHILDREN),
+static WORD_UT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iilties"),
         dictgen::InsensitiveStr::Ascii("iliatrian"),
@@ -8762,12 +8762,12 @@ pub static WORD_UT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_US_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_US_CHILDREN),
+static WORD_US_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_US_CHILDREN),
     value: None,
 };
 
-static WORD_US_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_US_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_USA_NODE),
     None,
     Some(&WORD_USC_NODE),
@@ -8796,12 +8796,12 @@ static WORD_US_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_USU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USU_CHILDREN),
+static WORD_USU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USU_CHILDREN),
     value: None,
 };
 
-pub static WORD_USU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("age"),
@@ -8839,23 +8839,23 @@ pub static WORD_USU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_UST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UST_CHILDREN),
+static WORD_UST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UST_CHILDREN),
     value: None,
 };
 
-pub static WORD_UST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["using"]],
     range: 3..=3,
 };
 
-static WORD_USS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USS_CHILDREN),
+static WORD_USS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USS_CHILDREN),
     value: None,
 };
 
-pub static WORD_USS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("eful"),
@@ -8877,23 +8877,23 @@ pub static WORD_USS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_USR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USR_CHILDREN),
+static WORD_USR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USR_CHILDREN),
     value: None,
 };
 
-pub static WORD_USR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["sure"]],
     range: 1..=1,
 };
 
-static WORD_USP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USP_CHILDREN),
+static WORD_USP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USP_CHILDREN),
     value: None,
 };
 
-pub static WORD_USP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ported"),
         dictgen::InsensitiveStr::Ascii("tart"),
@@ -8903,12 +8903,12 @@ pub static WORD_USP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_USN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USN_CHILDREN),
+static WORD_USN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USN_CHILDREN),
     value: None,
 };
 
-pub static WORD_USN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("ig"),
@@ -8918,23 +8918,23 @@ pub static WORD_USN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_USL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USL_CHILDREN),
+static WORD_USL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USL_CHILDREN),
     value: None,
 };
 
-pub static WORD_USL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["useless"]],
     range: 3..=3,
 };
 
-static WORD_USI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USI_CHILDREN),
+static WORD_USI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USI_CHILDREN),
     value: None,
 };
 
-pub static WORD_USI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -8966,23 +8966,23 @@ pub static WORD_USI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_USF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USF_CHILDREN),
+static WORD_USF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USF_CHILDREN),
     value: None,
 };
 
-pub static WORD_USF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ul")],
     values: &[&["useful"]],
     range: 2..=2,
 };
 
-static WORD_USE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USE_CHILDREN),
+static WORD_USE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USE_CHILDREN),
     value: None,
 };
 
-pub static WORD_USE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("bility"),
@@ -9052,12 +9052,12 @@ pub static WORD_USE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_USC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USC_CHILDREN),
+static WORD_USC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USC_CHILDREN),
     value: None,
 };
 
-pub static WORD_USC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aled"),
         dictgen::InsensitiveStr::Ascii("cess"),
@@ -9066,12 +9066,12 @@ pub static WORD_USC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_USA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USA_CHILDREN),
+static WORD_USA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USA_CHILDREN),
     value: None,
 };
 
-pub static WORD_USA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -9081,12 +9081,12 @@ pub static WORD_USA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_UR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UR_CHILDREN),
+static WORD_UR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainum"),
         dictgen::InsensitiveStr::Ascii("anuim"),
@@ -9118,12 +9118,12 @@ pub static WORD_UR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_UQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UQ_CHILDREN),
+static WORD_UQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ests"),
@@ -9132,12 +9132,12 @@ pub static WORD_UQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_UP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UP_CHILDREN),
+static WORD_UP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UP_CHILDREN),
     value: None,
 };
 
-static WORD_UP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UPA_NODE),
     None,
     Some(&WORD_UPC_NODE),
@@ -9166,12 +9166,12 @@ static WORD_UP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPT_CHILDREN),
+static WORD_UPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adeable"),
         dictgen::InsensitiveStr::Ascii("date"),
@@ -9197,12 +9197,12 @@ pub static WORD_UPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPS_CHILDREN),
+static WORD_UPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ream"),
         dictgen::InsensitiveStr::Ascii("reamed"),
@@ -9280,12 +9280,12 @@ pub static WORD_UPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_UPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPR_CHILDREN),
+static WORD_UPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -9311,12 +9311,12 @@ pub static WORD_UPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_UPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPP_CHILDREN),
+static WORD_UPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ercas"),
         dictgen::InsensitiveStr::Ascii("ler"),
@@ -9350,12 +9350,12 @@ pub static WORD_UPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_UPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPL_CHILDREN),
+static WORD_UPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("adad"),
@@ -9423,34 +9423,34 @@ pub static WORD_UPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPI_CHILDREN),
+static WORD_UPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("on")],
     values: &[&["upon"]],
     range: 2..=2,
 };
 
-static WORD_UPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPH_CHILDREN),
+static WORD_UPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olstry")],
     values: &[&["upholstery"]],
     range: 6..=6,
 };
 
-static WORD_UPG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPG_CHILDREN),
+static WORD_UPG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -9524,12 +9524,12 @@ pub static WORD_UPG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_UPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPE_CHILDREN),
+static WORD_UPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rcase"),
@@ -9539,12 +9539,12 @@ pub static WORD_UPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_UPD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPD_CHILDREN),
+static WORD_UPD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -9598,23 +9598,23 @@ pub static WORD_UPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPC_CHILDREN),
+static WORD_UPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("omming")],
     values: &[&["upcoming"]],
     range: 6..=6,
 };
 
-static WORD_UPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPA_CHILDREN),
+static WORD_UPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ck"),
         dictgen::InsensitiveStr::Ascii("date"),
@@ -9662,12 +9662,12 @@ pub static WORD_UPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UO_CHILDREN),
+static WORD_UO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("date"),
         dictgen::InsensitiveStr::Ascii("u"),
@@ -9676,12 +9676,12 @@ pub static WORD_UO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_UN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UN_CHILDREN),
+static WORD_UN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UN_CHILDREN),
     value: None,
 };
 
-static WORD_UN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNA_NODE),
     Some(&WORD_UNB_NODE),
     Some(&WORD_UNC_NODE),
@@ -9710,23 +9710,23 @@ static WORD_UN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNZ_NODE),
 ];
 
-static WORD_UNZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNZ_CHILDREN),
+static WORD_UNZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iped")],
     values: &[&["unzipped"]],
     range: 4..=4,
 };
 
-static WORD_UNX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNX_CHILDREN),
+static WORD_UNX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNX_CHILDREN),
     value: Some(&["unix"]),
 };
 
-pub static WORD_UNX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("epected"),
         dictgen::InsensitiveStr::Ascii("epectedly"),
@@ -9736,12 +9736,12 @@ pub static WORD_UNX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_UNW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNW_CHILDREN),
+static WORD_UNW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arrented"),
         dictgen::InsensitiveStr::Ascii("eildly"),
@@ -9773,12 +9773,12 @@ pub static WORD_UNW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_UNV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNV_CHILDREN),
+static WORD_UNV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailable"),
         dictgen::InsensitiveStr::Ascii("alid"),
@@ -9820,12 +9820,12 @@ pub static WORD_UNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_UNU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNU_CHILDREN),
+static WORD_UNU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blish"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -9861,12 +9861,12 @@ pub static WORD_UNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNT_CHILDREN),
+static WORD_UNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("argetted"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -9910,12 +9910,12 @@ pub static WORD_UNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_UNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNS_CHILDREN),
+static WORD_UNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNS_CHILDREN),
     value: None,
 };
 
-static WORD_UNS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNSA_NODE),
     None,
     Some(&WORD_UNSC_NODE),
@@ -9944,12 +9944,12 @@ static WORD_UNS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSY_CHILDREN),
+static WORD_UNSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chronise"),
         dictgen::InsensitiveStr::Ascii("chronised"),
@@ -9967,23 +9967,23 @@ pub static WORD_UNSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_UNSW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSW_CHILDREN),
+static WORD_UNSW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ithced")],
     values: &[&["unswitched"]],
     range: 6..=6,
 };
 
-static WORD_UNSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNSU_CHILDREN),
+static WORD_UNSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNSU_CHILDREN),
     value: None,
 };
 
-static WORD_UNSU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNSU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNSUA_NODE),
     Some(&WORD_UNSUB_NODE),
     Some(&WORD_UNSUC_NODE),
@@ -10012,12 +10012,12 @@ static WORD_UNSU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNSUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUS_CHILDREN),
+static WORD_UNSUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bcribe"),
         dictgen::InsensitiveStr::Ascii("bcribed"),
@@ -10039,12 +10039,12 @@ pub static WORD_UNSUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_UNSUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUR_CHILDREN),
+static WORD_UNSUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("prized"),
         dictgen::InsensitiveStr::Ascii("prizing"),
@@ -10054,12 +10054,12 @@ pub static WORD_UNSUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_UNSUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUP_CHILDREN),
+static WORD_UNSUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ortable"),
         dictgen::InsensitiveStr::Ascii("orted"),
@@ -10103,12 +10103,12 @@ pub static WORD_UNSUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNSUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUN_CHILDREN),
+static WORD_UNSUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("scribe"),
         dictgen::InsensitiveStr::Ascii("scribed"),
@@ -10117,45 +10117,45 @@ pub static WORD_UNSUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_UNSUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUF_CHILDREN),
+static WORD_UNSUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ficient")],
     values: &[&["insufficient"]],
     range: 7..=7,
 };
 
-static WORD_UNSUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUE_CHILDREN),
+static WORD_UNSUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["unused"]],
     range: 1..=1,
 };
 
-static WORD_UNSUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUD_CHILDREN),
+static WORD_UNSUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["unused", "unsuited"]],
     range: 2..=2,
 };
 
-static WORD_UNSUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUC_CHILDREN),
+static WORD_UNSUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccessful"),
         dictgen::InsensitiveStr::Ascii("ccessfully"),
@@ -10237,12 +10237,12 @@ pub static WORD_UNSUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_UNSUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUB_CHILDREN),
+static WORD_UNSUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cribe"),
         dictgen::InsensitiveStr::Ascii("scibe"),
@@ -10320,12 +10320,12 @@ pub static WORD_UNSUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_UNSUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUA_CHILDREN),
+static WORD_UNSUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -10334,12 +10334,12 @@ pub static WORD_UNSUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_UNST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNST_CHILDREN),
+static WORD_UNST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNST_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abel"),
         dictgen::InsensitiveStr::Ascii("albe"),
@@ -10371,12 +10371,12 @@ pub static WORD_UNST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_UNSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSS_CHILDREN),
+static WORD_UNSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uccesful"),
         dictgen::InsensitiveStr::Ascii("upported"),
@@ -10385,12 +10385,12 @@ pub static WORD_UNSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=8,
 };
 
-static WORD_UNSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSP_CHILDREN),
+static WORD_UNSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecializated"),
         dictgen::InsensitiveStr::Ascii("ecificed"),
@@ -10482,12 +10482,12 @@ pub static WORD_UNSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=12,
 };
 
-static WORD_UNSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSO_CHILDREN),
+static WORD_UNSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clicited"),
         dictgen::InsensitiveStr::Ascii("licated"),
@@ -10511,23 +10511,23 @@ pub static WORD_UNSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSL_CHILDREN),
+static WORD_UNSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["unless", "useless"]],
     range: 3..=3,
 };
 
-static WORD_UNSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSI_CHILDREN),
+static WORD_UNSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bscribed"),
         dictgen::InsensitiveStr::Ascii("bstantiated"),
@@ -10555,12 +10555,12 @@ pub static WORD_UNSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_UNSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSH_CHILDREN),
+static WORD_UNSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arable"),
         dictgen::InsensitiveStr::Ascii("fit"),
@@ -10578,23 +10578,23 @@ pub static WORD_UNSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_UNSG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSG_CHILDREN),
+static WORD_UNSG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ined")],
     values: &[&["unsigned"]],
     range: 4..=4,
 };
 
-static WORD_UNSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSE_CHILDREN),
+static WORD_UNSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arcahble"),
         dictgen::InsensitiveStr::Ascii("ccessful"),
@@ -10648,12 +10648,12 @@ pub static WORD_UNSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_UNSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSC_CHILDREN),
+static WORD_UNSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessful"),
         dictgen::InsensitiveStr::Ascii("ubscribe"),
@@ -10663,12 +10663,12 @@ pub static WORD_UNSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_UNSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSA_CHILDREN),
+static WORD_UNSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("nfe"),
@@ -10677,12 +10677,12 @@ pub static WORD_UNSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_UNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNR_CHILDREN),
+static WORD_UNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNR_CHILDREN),
     value: None,
 };
 
-static WORD_UNR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNRA_NODE),
     None,
     None,
@@ -10711,23 +10711,23 @@ static WORD_UNR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRW_CHILDREN),
+static WORD_UNRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itten")],
     values: &[&["unwritten"]],
     range: 5..=5,
 };
 
-static WORD_UNRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRP_CHILDREN),
+static WORD_UNRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oven"),
         dictgen::InsensitiveStr::Ascii("torect"),
@@ -10736,12 +10736,12 @@ pub static WORD_UNRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_UNRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRO_CHILDREN),
+static WORD_UNRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("ken"),
@@ -10751,45 +10751,45 @@ pub static WORD_UNRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_UNRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRN_CHILDREN),
+static WORD_UNRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aked")],
     values: &[&["unranked"]],
     range: 4..=4,
 };
 
-static WORD_UNRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRI_CHILDREN),
+static WORD_UNRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("stricted")],
     values: &[&["unrestricted"]],
     range: 8..=8,
 };
 
-static WORD_UNRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRG_CHILDREN),
+static WORD_UNRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("esiter")],
     values: &[&["unregister"]],
     range: 6..=6,
 };
 
-static WORD_UNRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNRE_CHILDREN),
+static WORD_UNRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNRE_CHILDREN),
     value: None,
 };
 
-static WORD_UNRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNREA_NODE),
     None,
     Some(&WORD_UNREC_NODE),
@@ -10818,12 +10818,12 @@ static WORD_UNRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRES_CHILDREN),
+static WORD_UNRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gister"),
         dictgen::InsensitiveStr::Ascii("gisterd"),
@@ -10873,12 +10873,12 @@ pub static WORD_UNRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_UNREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREP_CHILDREN),
+static WORD_UNREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entent"),
         dictgen::InsensitiveStr::Ascii("etant"),
@@ -10900,23 +10900,23 @@ pub static WORD_UNREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_UNREO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREO_CHILDREN),
+static WORD_UNREO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("verable")],
     values: &[&["unrecoverable"]],
     range: 7..=7,
 };
 
-static WORD_UNREL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREL_CHILDREN),
+static WORD_UNREL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aible"),
         dictgen::InsensitiveStr::Ascii("atd"),
@@ -10938,12 +10938,12 @@ pub static WORD_UNREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_UNREI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREI_CHILDREN),
+static WORD_UNREI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gister"),
         dictgen::InsensitiveStr::Ascii("gster"),
@@ -10961,12 +10961,12 @@ pub static WORD_UNREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_UNREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREG_CHILDREN),
+static WORD_UNREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ester"),
         dictgen::InsensitiveStr::Ascii("iste"),
@@ -11028,12 +11028,12 @@ pub static WORD_UNREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREC_CHILDREN),
+static WORD_UNREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gonized"),
         dictgen::InsensitiveStr::Ascii("hable"),
@@ -11065,12 +11065,12 @@ pub static WORD_UNREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_UNREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREA_CHILDREN),
+static WORD_UNREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cahable"),
         dictgen::InsensitiveStr::Ascii("cahble"),
@@ -11122,12 +11122,12 @@ pub static WORD_UNREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRA_CHILDREN),
+static WORD_UNRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kned"),
         dictgen::InsensitiveStr::Ascii("ndimized"),
@@ -11138,12 +11138,12 @@ pub static WORD_UNRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_UNQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNQ_CHILDREN),
+static WORD_UNQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arantined"),
         dictgen::InsensitiveStr::Ascii("aulified"),
@@ -11173,12 +11173,12 @@ pub static WORD_UNQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_UNP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNP_CHILDREN),
+static WORD_UNP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acke"),
         dictgen::InsensitiveStr::Ascii("acket"),
@@ -11292,12 +11292,12 @@ pub static WORD_UNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_UNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNO_CHILDREN),
+static WORD_UNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bstrusive"),
         dictgen::InsensitiveStr::Ascii("cde"),
@@ -11355,12 +11355,12 @@ pub static WORD_UNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_UNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNN_CHILDREN),
+static WORD_UNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acquired"),
         dictgen::InsensitiveStr::Ascii("cessarily"),
@@ -11484,12 +11484,12 @@ pub static WORD_UNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_UNM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNM_CHILDREN),
+static WORD_UNM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aanaged"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -11541,12 +11541,12 @@ pub static WORD_UNM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_UNL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNL_CHILDREN),
+static WORD_UNL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abled"),
         dictgen::InsensitiveStr::Ascii("ass"),
@@ -11592,12 +11592,12 @@ pub static WORD_UNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_UNK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNK_CHILDREN),
+static WORD_UNK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNK_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("known"),
         dictgen::InsensitiveStr::Ascii("mown"),
@@ -11661,12 +11661,12 @@ pub static WORD_UNK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_UNJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNJ_CHILDREN),
+static WORD_UNJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ustifed"),
         dictgen::InsensitiveStr::Ascii("ustifyed"),
@@ -11675,12 +11675,12 @@ pub static WORD_UNJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_UNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNI_CHILDREN),
+static WORD_UNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNI_CHILDREN),
     value: None,
 };
 
-static WORD_UNI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_UNIC_NODE),
@@ -11709,12 +11709,12 @@ static WORD_UNI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIV_CHILDREN),
+static WORD_UNIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eral"),
         dictgen::InsensitiveStr::Ascii("erally"),
@@ -11780,12 +11780,12 @@ pub static WORD_UNIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIT_CHILDREN),
+static WORD_UNIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("errupted"),
         dictgen::InsensitiveStr::Ascii("esstates"),
@@ -11829,12 +11829,12 @@ pub static WORD_UNIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_UNIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIS_CHILDREN),
+static WORD_UNIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gned"),
         dictgen::InsensitiveStr::Ascii("ntall"),
@@ -11856,12 +11856,12 @@ pub static WORD_UNIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIQ_CHILDREN),
+static WORD_UNIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ness"),
@@ -11887,12 +11887,12 @@ pub static WORD_UNIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_UNIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIO_CHILDREN),
+static WORD_UNIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIO_CHILDREN),
     value: Some(&["union"]),
 };
 
-pub static WORD_UNIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cde"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -11901,12 +11901,12 @@ pub static WORD_UNIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_UNIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNIN_CHILDREN),
+static WORD_UNIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNIN_CHILDREN),
     value: None,
 };
 
-static WORD_UNIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNINA_NODE),
     None,
     None,
@@ -11935,12 +11935,12 @@ static WORD_UNIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINT_CHILDREN),
+static WORD_UNINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ellegent"),
         dictgen::InsensitiveStr::Ascii("elligable"),
@@ -12016,12 +12016,12 @@ pub static WORD_UNINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_UNINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINS_CHILDREN),
+static WORD_UNINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipred"),
         dictgen::InsensitiveStr::Ascii("piried"),
@@ -12065,12 +12065,12 @@ pub static WORD_UNINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_UNINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINI_CHILDREN),
+static WORD_UNINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("shed"),
         dictgen::InsensitiveStr::Ascii("tailised"),
@@ -12120,12 +12120,12 @@ pub static WORD_UNINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNINF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINF_CHILDREN),
+static WORD_UNINF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rom"),
         dictgen::InsensitiveStr::Ascii("romed"),
@@ -12143,23 +12143,23 @@ pub static WORD_UNINF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_UNINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINA_CHILDREN),
+static WORD_UNINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mous")],
     values: &[&["unanimous"]],
     range: 4..=4,
 };
 
-static WORD_UNIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIM_CHILDREN),
+static WORD_UNIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iplemented"),
         dictgen::InsensitiveStr::Ascii("pemented"),
@@ -12193,12 +12193,12 @@ pub static WORD_UNIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=10,
 };
 
-static WORD_UNIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIL_CHILDREN),
+static WORD_UNIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIL_CHILDREN),
     value: Some(&["until"]),
 };
 
-pub static WORD_UNIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aterallly"),
         dictgen::InsensitiveStr::Ascii("ateraly"),
@@ -12218,34 +12218,34 @@ pub static WORD_UNIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_UNIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIH_CHILDREN),
+static WORD_UNIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("abited")],
     values: &[&["uninhabited"]],
     range: 6..=6,
 };
 
-static WORD_UNIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIG_CHILDREN),
+static WORD_UNIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ned")],
     values: &[&["unsigned"]],
     range: 3..=3,
 };
 
-static WORD_UNIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIF_CHILDREN),
+static WORD_UNIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("form"),
@@ -12287,12 +12287,12 @@ pub static WORD_UNIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_UNID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNID_CHILDREN),
+static WORD_UNID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNID_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entifiedly"),
         dictgen::InsensitiveStr::Ascii("imensionnal"),
@@ -12302,12 +12302,12 @@ pub static WORD_UNID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=11,
 };
 
-static WORD_UNIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIC_CHILDREN),
+static WORD_UNIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -12333,12 +12333,12 @@ pub static WORD_UNIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_UNH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNH_CHILDREN),
+static WORD_UNH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andeled"),
         dictgen::InsensitiveStr::Ascii("apppy"),
@@ -12368,12 +12368,12 @@ pub static WORD_UNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_UNG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNG_CHILDREN),
+static WORD_UNG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eneralizeable"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -12395,12 +12395,12 @@ pub static WORD_UNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_UNF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNF_CHILDREN),
+static WORD_UNF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailry"),
         dictgen::InsensitiveStr::Ascii("airy"),
@@ -12528,12 +12528,12 @@ pub static WORD_UNF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_UNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNE_CHILDREN),
+static WORD_UNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNE_CHILDREN),
     value: None,
 };
 
-static WORD_UNE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNEA_NODE),
     None,
     Some(&WORD_UNEC_NODE),
@@ -12562,12 +12562,12 @@ static WORD_UNE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNEX_CHILDREN),
+static WORD_UNEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNEX_CHILDREN),
     value: None,
 };
 
-static WORD_UNEX_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNEX_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_UNEXC_NODE),
@@ -12596,12 +12596,12 @@ static WORD_UNEX_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNEXS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEXS_CHILDREN),
+static WORD_UNEXS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEXS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEXS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEXS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pected"),
         dictgen::InsensitiveStr::Ascii("pectedly"),
@@ -12610,12 +12610,12 @@ pub static WORD_UNEXS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNEXP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEXP_CHILDREN),
+static WORD_UNEXP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEXP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEXP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEXP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acted"),
         dictgen::InsensitiveStr::Ascii("actedly"),
@@ -12725,12 +12725,12 @@ pub static WORD_UNEXP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_UNEXE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEXE_CHILDREN),
+static WORD_UNEXE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEXE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEXE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEXE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cpted"),
         dictgen::InsensitiveStr::Ascii("cptedly"),
@@ -12756,12 +12756,12 @@ pub static WORD_UNEXE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNEXC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEXC_CHILDREN),
+static WORD_UNEXC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEXC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEXC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEXC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("ectedly"),
@@ -12779,23 +12779,23 @@ pub static WORD_UNEXC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_UNEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEV_CHILDREN),
+static WORD_UNEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aluted")],
     values: &[&["unevaluated"]],
     range: 6..=6,
 };
 
-static WORD_UNES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNES_CHILDREN),
+static WORD_UNES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNES_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acpe"),
         dictgen::InsensitiveStr::Ascii("acped"),
@@ -12811,23 +12811,23 @@ pub static WORD_UNES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_UNER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNER_CHILDREN),
+static WORD_UNER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNER_CHILDREN),
     value: Some(&["under"]),
 };
 
-pub static WORD_UNER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lying")],
     values: &[&["underlying"]],
     range: 5..=5,
 };
 
-static WORD_UNEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEQ_CHILDREN),
+static WORD_UNEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ualities"),
         dictgen::InsensitiveStr::Ascii("uality"),
@@ -12836,12 +12836,12 @@ pub static WORD_UNEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEP_CHILDREN),
+static WORD_UNEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("ectedly"),
@@ -12850,12 +12850,12 @@ pub static WORD_UNEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_UNEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEN_CHILDREN),
+static WORD_UNEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crpt"),
         dictgen::InsensitiveStr::Ascii("crpted"),
@@ -12873,12 +12873,12 @@ pub static WORD_UNEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEM_CHILDREN),
+static WORD_UNEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ployeed"),
         dictgen::InsensitiveStr::Ascii("ployemnt"),
@@ -12900,12 +12900,12 @@ pub static WORD_UNEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEF_CHILDREN),
+static WORD_UNEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ficient"),
         dictgen::InsensitiveStr::Ascii("orceable"),
@@ -12915,23 +12915,23 @@ pub static WORD_UNEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_UNEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEE_CHILDREN),
+static WORD_UNEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ded")],
     values: &[&["unneeded", "unheeded", "needed"]],
     range: 3..=3,
 };
 
-static WORD_UNED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNED_CHILDREN),
+static WORD_UNED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNED_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cuated"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -12940,12 +12940,12 @@ pub static WORD_UNED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_UNEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEC_CHILDREN),
+static WORD_UNEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cesary"),
         dictgen::InsensitiveStr::Ascii("cessarily"),
@@ -12969,23 +12969,23 @@ pub static WORD_UNEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_UNEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEA_CHILDREN),
+static WORD_UNEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lthy")],
     values: &[&["unhealthy"]],
     range: 4..=4,
 };
 
-static WORD_UND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UND_CHILDREN),
+static WORD_UND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UND_CHILDREN),
     value: None,
 };
 
-static WORD_UND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UND_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -13014,12 +13014,12 @@ static WORD_UND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDU_CHILDREN),
+static WORD_UNDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cumented"),
         dictgen::InsensitiveStr::Ascii("ee"),
@@ -13035,12 +13035,12 @@ pub static WORD_UNDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_UNDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDR_CHILDREN),
+static WORD_UNDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eground"),
         dictgen::InsensitiveStr::Ascii("estand"),
@@ -13050,12 +13050,12 @@ pub static WORD_UNDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_UNDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDO_CHILDREN),
+static WORD_UNDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("comented"),
         dictgen::InsensitiveStr::Ascii("ctrinated"),
@@ -13093,12 +13093,12 @@ pub static WORD_UNDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_UNDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDI_CHILDREN),
+static WORD_UNDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("covered"),
         dictgen::InsensitiveStr::Ascii("serable"),
@@ -13114,12 +13114,12 @@ pub static WORD_UNDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_UNDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDF_CHILDREN),
+static WORD_UNDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -13129,12 +13129,12 @@ pub static WORD_UNDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_UNDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNDE_CHILDREN),
+static WORD_UNDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNDE_CHILDREN),
     value: None,
 };
 
-static WORD_UNDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNDE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_UNDEB_NODE),
     Some(&WORD_UNDEC_NODE),
@@ -13163,12 +13163,12 @@ static WORD_UNDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNDET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDET_CHILDREN),
+static WORD_UNDET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDET_CHILDREN),
     value: Some(&["under"]),
 };
 
-pub static WORD_UNDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecable"),
         dictgen::InsensitiveStr::Ascii("erministic"),
@@ -13186,12 +13186,12 @@ pub static WORD_UNDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_UNDES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDES_CHILDREN),
+static WORD_UNDES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDES_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("core"),
         dictgen::InsensitiveStr::Ascii("cored"),
@@ -13223,12 +13223,12 @@ pub static WORD_UNDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNDER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNDER_CHILDREN),
+static WORD_UNDER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNDER_CHILDREN),
     value: None,
 };
 
-static WORD_UNDER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNDER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNDERA_NODE),
     Some(&WORD_UNDERB_NODE),
     Some(&WORD_UNDERC_NODE),
@@ -13257,12 +13257,12 @@ static WORD_UNDER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNDERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERY_CHILDREN),
+static WORD_UNDERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERY_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -13271,12 +13271,12 @@ pub static WORD_UNDERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_UNDERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERW_CHILDREN),
+static WORD_UNDERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("ager"),
@@ -13316,12 +13316,12 @@ pub static WORD_UNDERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_UNDERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERU_CHILDREN),
+static WORD_UNDERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ltilization"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -13331,12 +13331,12 @@ pub static WORD_UNDERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_UNDERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERT_CHILDREN),
+static WORD_UNDERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("acker"),
@@ -13380,12 +13380,12 @@ pub static WORD_UNDERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_UNDERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERS_CHILDREN),
+static WORD_UNDERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acn"),
         dictgen::InsensitiveStr::Ascii("and"),
@@ -13457,12 +13457,12 @@ pub static WORD_UNDERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_UNDERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERR_CHILDREN),
+static WORD_UNDERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aged"),
         dictgen::InsensitiveStr::Ascii("aker"),
@@ -13480,12 +13480,12 @@ pub static WORD_UNDERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_UNDERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERP_CHILDREN),
+static WORD_UNDERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ining"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -13503,23 +13503,23 @@ pub static WORD_UNDERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_UNDERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERO_CHILDREN),
+static WORD_UNDERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["undergo"]],
     range: 1..=1,
 };
 
-static WORD_UNDERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERN_CHILDREN),
+static WORD_UNDERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earth"),
         dictgen::InsensitiveStr::Ascii("eeth"),
@@ -13537,12 +13537,12 @@ pub static WORD_UNDERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_UNDERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERM_CHILDREN),
+static WORD_UNDERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imes"),
         dictgen::InsensitiveStr::Ascii("iming"),
@@ -13576,12 +13576,12 @@ pub static WORD_UNDERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_UNDERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERL_CHILDREN),
+static WORD_UNDERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayed"),
         dictgen::InsensitiveStr::Ascii("aying"),
@@ -13619,12 +13619,12 @@ pub static WORD_UNDERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_UNDERH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERH_CHILDREN),
+static WORD_UNDERH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eight"),
         dictgen::InsensitiveStr::Ascii("welming"),
@@ -13634,12 +13634,12 @@ pub static WORD_UNDERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=7,
 };
 
-static WORD_UNDERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERG_CHILDREN),
+static WORD_UNDERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -13669,12 +13669,12 @@ pub static WORD_UNDERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_UNDERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERF_CHILDREN),
+static WORD_UNDERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aker"),
         dictgen::InsensitiveStr::Ascii("iend"),
@@ -13696,12 +13696,12 @@ pub static WORD_UNDERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_UNDERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERE_CHILDREN),
+static WORD_UNDERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sitmate"),
         dictgen::InsensitiveStr::Ascii("stamate"),
@@ -13729,23 +13729,23 @@ pub static WORD_UNDERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=10,
 };
 
-static WORD_UNDERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERD_CHILDREN),
+static WORD_UNDERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ong")],
     values: &[&["underdog"]],
     range: 3..=3,
 };
 
-static WORD_UNDERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERC_CHILDREN),
+static WORD_UNDERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ling"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -13755,12 +13755,12 @@ pub static WORD_UNDERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_UNDERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERB_CHILDREN),
+static WORD_UNDERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aker"),
         dictgen::InsensitiveStr::Ascii("og"),
@@ -13769,12 +13769,12 @@ pub static WORD_UNDERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_UNDERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERA_CHILDREN),
+static WORD_UNDERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stimate"),
         dictgen::InsensitiveStr::Ascii("stimated"),
@@ -13788,23 +13788,23 @@ pub static WORD_UNDERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=9,
 };
 
-static WORD_UNDEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEP_CHILDREN),
+static WORD_UNDEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("endend")],
     values: &[&["independent", "nondependent"]],
     range: 6..=6,
 };
 
-static WORD_UNDEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEN_CHILDREN),
+static WORD_UNDEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aible"),
         dictgen::InsensitiveStr::Ascii("aibly"),
@@ -13832,12 +13832,12 @@ pub static WORD_UNDEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_UNDEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEL_CHILDREN),
+static WORD_UNDEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ering"),
         dictgen::InsensitiveStr::Ascii("rying"),
@@ -13847,12 +13847,12 @@ pub static WORD_UNDEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_UNDEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEI_CHILDREN),
+static WORD_UNDEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nable"),
         dictgen::InsensitiveStr::Ascii("nably"),
@@ -13861,12 +13861,12 @@ pub static WORD_UNDEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_UNDEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEF_CHILDREN),
+static WORD_UNDEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ien"),
@@ -13896,45 +13896,45 @@ pub static WORD_UNDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_UNDED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDED_CHILDREN),
+static WORD_UNDED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDED_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ined")],
     values: &[&["undefined"]],
     range: 4..=4,
 };
 
-static WORD_UNDEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEC_CHILDREN),
+static WORD_UNDEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ideable")],
     values: &[&["undecidable"]],
     range: 7..=7,
 };
 
-static WORD_UNDEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEB_CHILDREN),
+static WORD_UNDEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iably")],
     values: &[&["undeniably"]],
     range: 5..=5,
 };
 
-static WORD_UNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNC_CHILDREN),
+static WORD_UNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNC_CHILDREN),
     value: None,
 };
 
-static WORD_UNC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNCA_NODE),
     None,
     None,
@@ -13963,23 +13963,23 @@ static WORD_UNC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCR_CHILDREN),
+static WORD_UNCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ypted")],
     values: &[&["unencrypted"]],
     range: 5..=5,
 };
 
-static WORD_UNCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNCO_CHILDREN),
+static WORD_UNCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNCO_CHILDREN),
     value: None,
 };
 
-static WORD_UNCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -14008,23 +14008,23 @@ static WORD_UNCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNCOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOV_CHILDREN),
+static WORD_UNCOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erted")],
     values: &[&["unconverted"]],
     range: 5..=5,
 };
 
-static WORD_UNCOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOU_CHILDREN),
+static WORD_UNCOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncious"),
         dictgen::InsensitiveStr::Ascii("nciously"),
@@ -14034,12 +14034,12 @@ pub static WORD_UNCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOR_CHILDREN),
+static WORD_UNCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectly"),
         dictgen::InsensitiveStr::Ascii("elated"),
@@ -14057,12 +14057,12 @@ pub static WORD_UNCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_UNCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNCON_CHILDREN),
+static WORD_UNCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNCON_CHILDREN),
     value: None,
 };
 
-static WORD_UNCON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNCON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_UNCONC_NODE),
@@ -14091,12 +14091,12 @@ static WORD_UNCON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNCONV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONV_CHILDREN),
+static WORD_UNCONV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectional"),
         dictgen::InsensitiveStr::Ascii("encional"),
@@ -14120,12 +14120,12 @@ pub static WORD_UNCONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=9,
 };
 
-static WORD_UNCONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONT_CHILDREN),
+static WORD_UNCONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itutional"),
         dictgen::InsensitiveStr::Ascii("rained"),
@@ -14155,12 +14155,12 @@ pub static WORD_UNCONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=10,
 };
 
-static WORD_UNCONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONS_CHILDREN),
+static WORD_UNCONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciosly"),
         dictgen::InsensitiveStr::Ascii("cioulsy"),
@@ -14194,23 +14194,23 @@ pub static WORD_UNCONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_UNCONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONN_CHILDREN),
+static WORD_UNCONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ectes")],
     values: &[&["unconnected"]],
     range: 5..=5,
 };
 
-static WORD_UNCONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONF_CHILDREN),
+static WORD_UNCONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iged"),
         dictgen::InsensitiveStr::Ascii("ortability"),
@@ -14226,12 +14226,12 @@ pub static WORD_UNCONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=10,
 };
 
-static WORD_UNCOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOND_CHILDREN),
+static WORD_UNCOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isional"),
         dictgen::InsensitiveStr::Ascii("isionaly"),
@@ -14283,12 +14283,12 @@ pub static WORD_UNCOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=10,
 };
 
-static WORD_UNCONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONC_CHILDREN),
+static WORD_UNCONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ious"),
         dictgen::InsensitiveStr::Ascii("iousness"),
@@ -14310,12 +14310,12 @@ pub static WORD_UNCONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=9,
 };
 
-static WORD_UNCOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOM_CHILDREN),
+static WORD_UNCOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ented"),
@@ -14421,23 +14421,23 @@ pub static WORD_UNCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_UNCOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOG_CHILDREN),
+static WORD_UNCOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nized")],
     values: &[&["unrecognized"]],
     range: 5..=5,
 };
 
-static WORD_UNCOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOD_CHILDREN),
+static WORD_UNCOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("itionally"),
@@ -14446,34 +14446,34 @@ pub static WORD_UNCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_UNCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCL_CHILDREN),
+static WORD_UNCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["uncle", "unclear", "uncles"]],
     range: 2..=2,
 };
 
-static WORD_UNCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCK_CHILDREN),
+static WORD_UNCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nown")],
     values: &[&["unknown"]],
     range: 4..=4,
 };
 
-static WORD_UNCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCH_CHILDREN),
+static WORD_UNCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ache"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -14505,12 +14505,12 @@ pub static WORD_UNCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_UNCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCE_CHILDREN),
+static WORD_UNCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCE_CHILDREN),
     value: Some(&["once"]),
 };
 
-pub static WORD_UNCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hck"),
         dictgen::InsensitiveStr::Ascii("hcked"),
@@ -14572,12 +14572,12 @@ pub static WORD_UNCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_UNCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCA_CHILDREN),
+static WORD_UNCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hnged"),
         dictgen::InsensitiveStr::Ascii("lcualted"),
@@ -14597,12 +14597,12 @@ pub static WORD_UNCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNB_CHILDREN),
+static WORD_UNB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alanaced"),
         dictgen::InsensitiveStr::Ascii("alenced"),
@@ -14720,12 +14720,12 @@ pub static WORD_UNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_UNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNA_CHILDREN),
+static WORD_UNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNA_CHILDREN),
     value: None,
 };
 
-static WORD_UNA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_UNAB_NODE),
     Some(&WORD_UNAC_NODE),
@@ -14754,23 +14754,23 @@ static WORD_UNA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAW_CHILDREN),
+static WORD_UNAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nsered")],
     values: &[&["unanswered"]],
     range: 6..=6,
 };
 
-static WORD_UNAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAV_CHILDREN),
+static WORD_UNAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aiable"),
         dictgen::InsensitiveStr::Ascii("aialable"),
@@ -14818,12 +14818,12 @@ pub static WORD_UNAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_UNAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAU_CHILDREN),
+static WORD_UNAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thenicated"),
         dictgen::InsensitiveStr::Ascii("thenticed"),
@@ -14841,12 +14841,12 @@ pub static WORD_UNAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=10,
 };
 
-static WORD_UNAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAT_CHILDREN),
+static WORD_UNAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("henticated"),
         dictgen::InsensitiveStr::Ascii("horised"),
@@ -14874,12 +14874,12 @@ pub static WORD_UNAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_UNAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAS_CHILDREN),
+static WORD_UNAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igned"),
         dictgen::InsensitiveStr::Ascii("nwered"),
@@ -14899,12 +14899,12 @@ pub static WORD_UNAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_UNAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAR_CHILDREN),
+static WORD_UNAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chvied"),
         dictgen::InsensitiveStr::Ascii("chving"),
@@ -14913,23 +14913,23 @@ pub static WORD_UNAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_UNAQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAQ_CHILDREN),
+static WORD_UNAQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uired")],
     values: &[&["unacquired"]],
     range: 5..=5,
 };
 
-static WORD_UNAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAP_CHILDREN),
+static WORD_UNAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pealling"),
         dictgen::InsensitiveStr::Ascii("peasing"),
@@ -14961,12 +14961,12 @@ pub static WORD_UNAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=11,
 };
 
-static WORD_UNAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAN_CHILDREN),
+static WORD_UNAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imoulsy"),
         dictgen::InsensitiveStr::Ascii("imuous"),
@@ -15010,12 +15010,12 @@ pub static WORD_UNAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAM_CHILDREN),
+static WORD_UNAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bigious"),
         dictgen::InsensitiveStr::Ascii("bigous"),
@@ -15035,12 +15035,12 @@ pub static WORD_UNAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_UNAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAL_CHILDREN),
+static WORD_UNAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -15058,34 +15058,34 @@ pub static WORD_UNAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_UNAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAI_CHILDREN),
+static WORD_UNAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("valable")],
     values: &[&["unavailable"]],
     range: 7..=7,
 };
 
-static WORD_UNAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAH_CHILDREN),
+static WORD_UNAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ppy")],
     values: &[&["unhappy"]],
     range: 3..=3,
 };
 
-static WORD_UNAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAF_CHILDREN),
+static WORD_UNAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("fliated"),
@@ -15094,12 +15094,12 @@ pub static WORD_UNAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_UNAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAD_CHILDREN),
+static WORD_UNAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("vertantly"),
         dictgen::InsensitiveStr::Ascii("vertedly"),
@@ -15115,12 +15115,12 @@ pub static WORD_UNAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_UNAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAC_CHILDREN),
+static WORD_UNAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("captable"),
         dictgen::InsensitiveStr::Ascii("ceptible"),
@@ -15142,12 +15142,12 @@ pub static WORD_UNAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_UNAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAB_CHILDREN),
+static WORD_UNAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailable"),
         dictgen::InsensitiveStr::Ascii("ale"),
@@ -15165,12 +15165,12 @@ pub static WORD_UNAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_UM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UM_CHILDREN),
+static WORD_UM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ambiguous"),
         dictgen::InsensitiveStr::Ascii("ark"),
@@ -15214,12 +15214,12 @@ pub static WORD_UM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_UL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UL_CHILDREN),
+static WORD_UL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("imited"),
@@ -15281,12 +15281,12 @@ pub static WORD_UL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_UK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UK_CHILDREN),
+static WORD_UK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UK_CHILDREN),
     value: None,
 };
 
-pub static WORD_UK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arine"),
         dictgen::InsensitiveStr::Ascii("nown"),
@@ -15334,12 +15334,12 @@ pub static WORD_UK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_UI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UI_CHILDREN),
+static WORD_UI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nque"),
         dictgen::InsensitiveStr::Ascii("que"),
@@ -15361,23 +15361,23 @@ pub static WORD_UI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_UH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UH_CHILDREN),
+static WORD_UH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("andled")],
     values: &[&["unhandled"]],
     range: 6..=6,
 };
 
-static WORD_UG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UG_CHILDREN),
+static WORD_UG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gly"),
         dictgen::InsensitiveStr::Ascii("glyness"),
@@ -15399,12 +15399,12 @@ pub static WORD_UG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_UF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UF_CHILDREN),
+static WORD_UF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fer"),
         dictgen::InsensitiveStr::Ascii("fered"),
@@ -15415,12 +15415,12 @@ pub static WORD_UF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_UE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UE_CHILDREN),
+static WORD_UE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UE_CHILDREN),
     value: Some(&["use", "due"]),
 };
 
-pub static WORD_UE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ful"),
         dictgen::InsensitiveStr::Ascii("gister"),
@@ -15452,12 +15452,12 @@ pub static WORD_UE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_UD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UD_CHILDREN),
+static WORD_UD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -15509,23 +15509,23 @@ pub static WORD_UD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_UC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UC_CHILDREN),
+static WORD_UC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rrently")],
     values: &[&["currently"]],
     range: 7..=7,
 };
 
-static WORD_UB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UB_CHILDREN),
+static WORD_UB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elieveble"),
         dictgen::InsensitiveStr::Ascii("elievebly"),
@@ -15571,12 +15571,12 @@ pub static WORD_UB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_T_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_T_CHILDREN),
+static WORD_T_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_T_CHILDREN),
     value: None,
 };
 
-static WORD_T_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_T_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TA_NODE),
     Some(&WORD_TB_NODE),
     Some(&WORD_TC_NODE),
@@ -15605,12 +15605,12 @@ static WORD_T_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TY_CHILDREN),
+static WORD_TY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("elnol"),
@@ -15726,12 +15726,12 @@ pub static WORD_TY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_TW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TW_CHILDREN),
+static WORD_TW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eek"),
         dictgen::InsensitiveStr::Ascii("eeked"),
@@ -15765,12 +15765,12 @@ pub static WORD_TW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_TU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TU_CHILDREN),
+static WORD_TU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TU_CHILDREN),
     value: None,
 };
 
-static WORD_TU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_TUC_NODE),
@@ -15799,12 +15799,12 @@ static WORD_TU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUT_CHILDREN),
+static WORD_TUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("oriales"),
@@ -15824,12 +15824,12 @@ pub static WORD_TUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_TUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUS_CHILDREN),
+static WORD_TUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("con"),
         dictgen::InsensitiveStr::Ascii("day"),
@@ -15849,12 +15849,12 @@ pub static WORD_TUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUR_CHILDREN),
+static WORD_TUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ains"),
@@ -15924,12 +15924,12 @@ pub static WORD_TUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_TUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUP_CHILDREN),
+static WORD_TUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -15951,12 +15951,12 @@ pub static WORD_TUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUO_CHILDREN),
+static WORD_TUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tiral"),
         dictgen::InsensitiveStr::Ascii("tirals"),
@@ -15965,12 +15965,12 @@ pub static WORD_TUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_TUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUN_CHILDREN),
+static WORD_TUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elled"),
         dictgen::InsensitiveStr::Ascii("elling"),
@@ -16004,34 +16004,34 @@ pub static WORD_TUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUH_CHILDREN),
+static WORD_TUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mbnail")],
     values: &[&["thumbnail"]],
     range: 6..=6,
 };
 
-static WORD_TUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUF_CHILDREN),
+static WORD_TUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ure")],
     values: &[&["future"]],
     range: 3..=3,
 };
 
-static WORD_TUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUE_CHILDREN),
+static WORD_TUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sdey"),
         dictgen::InsensitiveStr::Ascii("sdsay"),
@@ -16041,12 +16041,12 @@ pub static WORD_TUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_TUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUC_CHILDREN),
+static WORD_TUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("ans"),
@@ -16055,12 +16055,12 @@ pub static WORD_TUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_TT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TT_CHILDREN),
+static WORD_TT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ached"),
         dictgen::InsensitiveStr::Ascii("ests"),
@@ -16082,12 +16082,12 @@ pub static WORD_TT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TS_CHILDREN),
+static WORD_TS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amina"),
         dictgen::InsensitiveStr::Ascii("nuami"),
@@ -16105,12 +16105,12 @@ pub static WORD_TS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_TR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TR_CHILDREN),
+static WORD_TR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TR_CHILDREN),
     value: None,
 };
 
-static WORD_TR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRA_NODE),
     None,
     Some(&WORD_TRC_NODE),
@@ -16139,12 +16139,12 @@ static WORD_TR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRY_CHILDREN),
+static WORD_TRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahrd"),
         dictgen::InsensitiveStr::Ascii("annical"),
@@ -16180,12 +16180,12 @@ pub static WORD_TRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRU_CHILDREN),
+static WORD_TRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRU_CHILDREN),
     value: None,
 };
 
-static WORD_TRU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRUA_NODE),
     Some(&WORD_TRUB_NODE),
     Some(&WORD_TRUC_NODE),
@@ -16214,23 +16214,23 @@ static WORD_TRU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRUW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUW_CHILDREN),
+static WORD_TRUW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUW_CHILDREN),
     value: Some(&["true"]),
 };
 
-pub static WORD_TRUW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_TRUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUT_CHILDREN),
+static WORD_TRUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hfullly"),
         dictgen::InsensitiveStr::Ascii("hfuly"),
@@ -16239,12 +16239,12 @@ pub static WORD_TRUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUS_CHILDREN),
+static WORD_TRUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hworthy"),
@@ -16274,23 +16274,23 @@ pub static WORD_TRUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_TRUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUR_CHILDREN),
+static WORD_TRUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ned")],
     values: &[&["turned"]],
     range: 3..=3,
 };
 
-static WORD_TRUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUN_CHILDREN),
+static WORD_TRUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUN_CHILDREN),
     value: Some(&["turn"]),
 };
 
-pub static WORD_TRUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acted"),
         dictgen::InsensitiveStr::Ascii("cat"),
@@ -16322,23 +16322,23 @@ pub static WORD_TRUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_TRUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUM_CHILDREN),
+static WORD_TRUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("endously")],
     values: &[&["tremendously"]],
     range: 8..=8,
 };
 
-static WORD_TRUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUL_CHILDREN),
+static WORD_TRUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ey"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -16347,23 +16347,23 @@ pub static WORD_TRUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=2,
 };
 
-static WORD_TRUK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUK_CHILDREN),
+static WORD_TRUK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ish")],
     values: &[&["turkish"]],
     range: 3..=3,
 };
 
-static WORD_TRUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUI_CHILDREN),
+static WORD_TRUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("mph"),
@@ -16372,12 +16372,12 @@ pub static WORD_TRUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TRUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUG_CHILDREN),
+static WORD_TRUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -16387,12 +16387,12 @@ pub static WORD_TRUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TRUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUE_CHILDREN),
+static WORD_TRUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lly"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -16401,23 +16401,23 @@ pub static WORD_TRUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TRUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUD_CHILDREN),
+static WORD_TRUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nle")],
     values: &[&["trundle"]],
     range: 3..=3,
 };
 
-static WORD_TRUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUC_CHILDREN),
+static WORD_TRUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -16445,12 +16445,12 @@ pub static WORD_TRUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_TRUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUB_CHILDREN),
+static WORD_TRUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ador"),
         dictgen::InsensitiveStr::Ascii("adors"),
@@ -16484,12 +16484,12 @@ pub static WORD_TRUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TRUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUA_CHILDREN),
+static WORD_TRUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matic"),
         dictgen::InsensitiveStr::Ascii("matized"),
@@ -16498,12 +16498,12 @@ pub static WORD_TRUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRR_CHILDREN),
+static WORD_TRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iger"),
         dictgen::InsensitiveStr::Ascii("igered"),
@@ -16527,23 +16527,23 @@ pub static WORD_TRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_TRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRP_CHILDREN),
+static WORD_TRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oical")],
     values: &[&["tropical"]],
     range: 5..=5,
 };
 
-static WORD_TRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRO_CHILDREN),
+static WORD_TRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRO_CHILDREN),
     value: Some(&["to"]),
 };
 
-static WORD_TRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_TROB_NODE),
     Some(&WORD_TROC_NODE),
@@ -16572,23 +16572,23 @@ static WORD_TRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TROW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROW_CHILDREN),
+static WORD_TROW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("n")],
     values: &[&["thrown"]],
     range: 1..=1,
 };
 
-static WORD_TROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROU_CHILDREN),
+static WORD_TROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bador"),
         dictgen::InsensitiveStr::Ascii("badors"),
@@ -16646,12 +16646,12 @@ pub static WORD_TROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_TROT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROT_CHILDREN),
+static WORD_TROT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("illa"),
         dictgen::InsensitiveStr::Ascii("ski"),
@@ -16699,12 +16699,12 @@ pub static WORD_TROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TROP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROP_CHILDREN),
+static WORD_TROP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cial"),
         dictgen::InsensitiveStr::Ascii("edo"),
@@ -16713,12 +16713,12 @@ pub static WORD_TROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_TROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROO_CHILDREN),
+static WORD_TROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("so"),
         dictgen::InsensitiveStr::Ascii("sos"),
@@ -16734,23 +16734,23 @@ pub static WORD_TROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_TRON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRON_CHILDREN),
+static WORD_TRON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRON_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ado")],
     values: &[&["tornado"]],
     range: 3..=3,
 };
 
-static WORD_TROL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROL_CHILDREN),
+static WORD_TROL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eld"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -16761,23 +16761,23 @@ pub static WORD_TROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_TROH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROH_CHILDREN),
+static WORD_TROH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pies")],
     values: &[&["trophies"]],
     range: 4..=4,
 };
 
-static WORD_TROG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROG_CHILDREN),
+static WORD_TROG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ladite"),
         dictgen::InsensitiveStr::Ascii("ladites"),
@@ -16815,34 +16815,34 @@ pub static WORD_TROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_TROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROC_CHILDREN),
+static WORD_TROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hlight")],
     values: &[&["torchlight"]],
     range: 6..=6,
 };
 
-static WORD_TROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROB_CHILDREN),
+static WORD_TROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["trouble"]],
     range: 2..=2,
 };
 
-static WORD_TRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRN_CHILDREN),
+static WORD_TRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asfers"),
         dictgen::InsensitiveStr::Ascii("asmit"),
@@ -16866,12 +16866,12 @@ pub static WORD_TRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_TRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRI_CHILDREN),
+static WORD_TRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRI_CHILDREN),
     value: None,
 };
 
-static WORD_TRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRIA_NODE),
     Some(&WORD_TRIB_NODE),
     Some(&WORD_TRIC_NODE),
@@ -16900,23 +16900,23 @@ static WORD_TRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIY_CHILDREN),
+static WORD_TRIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["trying"]],
     range: 3..=3,
 };
 
-static WORD_TRIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIV_CHILDREN),
+static WORD_TRIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -16927,12 +16927,12 @@ pub static WORD_TRIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_TRIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIU_CHILDREN),
+static WORD_TRIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angulate"),
         dictgen::InsensitiveStr::Ascii("mpth"),
@@ -16941,12 +16941,12 @@ pub static WORD_TRIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_TRIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIS_CHILDREN),
+static WORD_TRIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cadecafobia"),
         dictgen::InsensitiveStr::Ascii("cadecaphobia"),
@@ -16974,12 +16974,12 @@ pub static WORD_TRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 11..=13,
 };
 
-static WORD_TRIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIP_CHILDREN),
+static WORD_TRIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("eld"),
@@ -17009,12 +17009,12 @@ pub static WORD_TRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TRIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIO_CHILDREN),
+static WORD_TRIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lgy"),
         dictgen::InsensitiveStr::Ascii("logy"),
@@ -17023,12 +17023,12 @@ pub static WORD_TRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_TRIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIN_CHILDREN),
+static WORD_TRIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agle"),
         dictgen::InsensitiveStr::Ascii("agles"),
@@ -17062,12 +17062,12 @@ pub static WORD_TRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_TRIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIM_CHILDREN),
+static WORD_TRIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -17083,12 +17083,12 @@ pub static WORD_TRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TRIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIL_CHILDREN),
+static WORD_TRIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inar"),
         dictgen::InsensitiveStr::Ascii("ineal"),
@@ -17098,12 +17098,12 @@ pub static WORD_TRIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_TRIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIK_CHILDREN),
+static WORD_TRIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIK_CHILDREN),
     value: Some(&["trick", "trike"]),
 };
 
-pub static WORD_TRIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ery"),
@@ -17119,12 +17119,12 @@ pub static WORD_TRIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_TRIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIG_CHILDREN),
+static WORD_TRIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -17172,12 +17172,12 @@ pub static WORD_TRIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_TRID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRID_CHILDREN),
+static WORD_TRID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRID_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itional"),
         dictgen::InsensitiveStr::Ascii("net"),
@@ -17186,12 +17186,12 @@ pub static WORD_TRID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIC_CHILDREN),
+static WORD_TRIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("key"),
         dictgen::InsensitiveStr::Ascii("kyer"),
@@ -17201,12 +17201,12 @@ pub static WORD_TRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_TRIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIB_CHILDREN),
+static WORD_TRIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uanl"),
         dictgen::InsensitiveStr::Ascii("unaal"),
@@ -17215,12 +17215,12 @@ pub static WORD_TRIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_TRIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIA_CHILDREN),
+static WORD_TRIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ler"),
         dictgen::InsensitiveStr::Ascii("lers"),
@@ -17278,12 +17278,12 @@ pub static WORD_TRIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_TRH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRH_CHILDREN),
+static WORD_TRH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("illing"),
@@ -17294,12 +17294,12 @@ pub static WORD_TRH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_TRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRG_CHILDREN),
+static WORD_TRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gers"),
         dictgen::InsensitiveStr::Ascii("istration"),
@@ -17308,12 +17308,12 @@ pub static WORD_TRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_TRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRE_CHILDREN),
+static WORD_TRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRE_CHILDREN),
     value: Some(&["tree"]),
 };
 
-pub static WORD_TRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adet"),
         dictgen::InsensitiveStr::Ascii("aeted"),
@@ -17429,23 +17429,23 @@ pub static WORD_TRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRC_CHILDREN),
+static WORD_TRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["tracer"]],
     range: 2..=2,
 };
 
-static WORD_TRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRA_CHILDREN),
+static WORD_TRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRA_CHILDREN),
     value: None,
 };
 
-static WORD_TRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_TRAB_NODE),
     Some(&WORD_TRAC_NODE),
@@ -17474,12 +17474,12 @@ static WORD_TRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAV_CHILDREN),
+static WORD_TRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eersal"),
@@ -17575,12 +17575,12 @@ pub static WORD_TRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TRAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAU_CHILDREN),
+static WORD_TRAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matisch"),
         dictgen::InsensitiveStr::Ascii("metized"),
@@ -17590,12 +17590,12 @@ pub static WORD_TRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_TRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAT_CHILDREN),
+static WORD_TRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ior"),
         dictgen::InsensitiveStr::Ascii("iors"),
@@ -17604,12 +17604,12 @@ pub static WORD_TRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_TRAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRAS_CHILDREN),
+static WORD_TRAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRAS_CHILDREN),
     value: None,
 };
 
-static WORD_TRAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRAS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRASA_NODE),
     None,
     Some(&WORD_TRASC_NODE),
@@ -17638,23 +17638,23 @@ static WORD_TRAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRASV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASV_CHILDREN),
+static WORD_TRASV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ersing")],
     values: &[&["traversing"]],
     range: 6..=6,
 };
 
-static WORD_TRASP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASP_CHILDREN),
+static WORD_TRASP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arency"),
         dictgen::InsensitiveStr::Ascii("arent"),
@@ -17688,12 +17688,12 @@ pub static WORD_TRASP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_TRASN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASN_CHILDREN),
+static WORD_TRASN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("action"),
         dictgen::InsensitiveStr::Ascii("actions"),
@@ -17781,12 +17781,12 @@ pub static WORD_TRASN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_TRASM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASM_CHILDREN),
+static WORD_TRASM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ission"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -17795,12 +17795,12 @@ pub static WORD_TRASM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TRASL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASL_CHILDREN),
+static WORD_TRASL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("alated"),
@@ -17832,12 +17832,12 @@ pub static WORD_TRASL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_TRASI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASI_CHILDREN),
+static WORD_TRASI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tive"),
@@ -17846,12 +17846,12 @@ pub static WORD_TRASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_TRASF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASF_CHILDREN),
+static WORD_TRASF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erred"),
@@ -17885,12 +17885,12 @@ pub static WORD_TRASF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_TRASC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASC_CHILDREN),
+static WORD_TRASC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ription"),
@@ -17899,34 +17899,34 @@ pub static WORD_TRASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRASA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASA_CHILDREN),
+static WORD_TRASA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ction")],
     values: &[&["transaction"]],
     range: 5..=5,
 };
 
-static WORD_TRAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAR_CHILDREN),
+static WORD_TRAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("get")],
     values: &[&["target"]],
     range: 3..=3,
 };
 
-static WORD_TRAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAP_CHILDREN),
+static WORD_TRAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eziod"),
         dictgen::InsensitiveStr::Ascii("eziodal"),
@@ -17935,12 +17935,12 @@ pub static WORD_TRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRAN_CHILDREN),
+static WORD_TRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRAN_CHILDREN),
     value: None,
 };
 
-static WORD_TRAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRANA_NODE),
     None,
     Some(&WORD_TRANC_NODE),
@@ -17969,12 +17969,12 @@ static WORD_TRAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRANZ_NODE),
 ];
 
-static WORD_TRANZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANZ_CHILDREN),
+static WORD_TRANZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("former"),
         dictgen::InsensitiveStr::Ascii("istor"),
@@ -17990,12 +17990,12 @@ pub static WORD_TRANZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TRANV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANV_CHILDREN),
+static WORD_TRANV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ersal"),
         dictgen::InsensitiveStr::Ascii("erse"),
@@ -18011,12 +18011,12 @@ pub static WORD_TRANV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_TRANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRANS_CHILDREN),
+static WORD_TRANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRANS_CHILDREN),
     value: None,
 };
 
-static WORD_TRANS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRANS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRANSA_NODE),
     None,
     Some(&WORD_TRANSC_NODE),
@@ -18045,12 +18045,12 @@ static WORD_TRANS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRANSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSY_CHILDREN),
+static WORD_TRANSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lmania"),
         dictgen::InsensitiveStr::Ascii("lvanai"),
@@ -18066,12 +18066,12 @@ pub static WORD_TRANSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=7,
 };
 
-static WORD_TRANSV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSV_CHILDREN),
+static WORD_TRANSV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orm"),
         dictgen::InsensitiveStr::Ascii("ormation"),
@@ -18089,23 +18089,23 @@ pub static WORD_TRANSV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_TRANSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSU_CHILDREN),
+static WORD_TRANSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lcent")],
     values: &[&["translucent"]],
     range: 5..=5,
 };
 
-static WORD_TRANST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANST_CHILDREN),
+static WORD_TRANST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANST_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ator"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -18137,12 +18137,12 @@ pub static WORD_TRANST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_TRANSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSS_CHILDREN),
+static WORD_TRANSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cript"),
         dictgen::InsensitiveStr::Ascii("cription"),
@@ -18168,12 +18168,12 @@ pub static WORD_TRANSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_TRANSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRANSP_CHILDREN),
+static WORD_TRANSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRANSP_CHILDREN),
     value: None,
 };
 
-static WORD_TRANSP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRANSP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRANSPA_NODE),
     None,
     None,
@@ -18202,23 +18202,23 @@ static WORD_TRANSP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRANSPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPS_CHILDREN),
+static WORD_TRANSPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ition")],
     values: &[&["transposition"]],
     range: 5..=5,
 };
 
-static WORD_TRANSPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPR_CHILDREN),
+static WORD_TRANSPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encies"),
         dictgen::InsensitiveStr::Ascii("ency"),
@@ -18250,12 +18250,12 @@ pub static WORD_TRANSPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_TRANSPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPO_CHILDREN),
+static WORD_TRANSPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -18299,12 +18299,12 @@ pub static WORD_TRANSPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_TRANSPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPL_CHILDREN),
+static WORD_TRANSPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("anet"),
@@ -18326,12 +18326,12 @@ pub static WORD_TRANSPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_TRANSPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPH_CHILDREN),
+static WORD_TRANSPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oic"),
         dictgen::InsensitiveStr::Ascii("onic"),
@@ -18341,12 +18341,12 @@ pub static WORD_TRANSPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_TRANSPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPE_CHILDREN),
+static WORD_TRANSPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncies"),
         dictgen::InsensitiveStr::Ascii("ncy"),
@@ -18376,12 +18376,12 @@ pub static WORD_TRANSPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=7,
 };
 
-static WORD_TRANSPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPA_CHILDREN),
+static WORD_TRANSPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("cencies"),
@@ -18481,12 +18481,12 @@ pub static WORD_TRANSPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_TRANSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSO_CHILDREN),
+static WORD_TRANSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cde"),
         dictgen::InsensitiveStr::Ascii("cded"),
@@ -18548,12 +18548,12 @@ pub static WORD_TRANSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_TRANSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSM_CHILDREN),
+static WORD_TRANSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atter"),
         dictgen::InsensitiveStr::Ascii("ision"),
@@ -18623,12 +18623,12 @@ pub static WORD_TRANSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_TRANSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSL_CHILDREN),
+static WORD_TRANSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("astion"),
         dictgen::InsensitiveStr::Ascii("atation"),
@@ -18678,12 +18678,12 @@ pub static WORD_TRANSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_TRANSK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSK_CHILDREN),
+static WORD_TRANSK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ript"),
         dictgen::InsensitiveStr::Ascii("ription"),
@@ -18692,12 +18692,12 @@ pub static WORD_TRANSK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_TRANSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSI_CHILDREN),
+static WORD_TRANSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cion"),
         dictgen::InsensitiveStr::Ascii("cional"),
@@ -18785,23 +18785,23 @@ pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_TRANSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSH_CHILDREN),
+static WORD_TRANSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pobic")],
     values: &[&["transphobic"]],
     range: 5..=5,
 };
 
-static WORD_TRANSG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSG_CHILDREN),
+static WORD_TRANSG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eder"),
         dictgen::InsensitiveStr::Ascii("emder"),
@@ -18831,12 +18831,12 @@ pub static WORD_TRANSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_TRANSF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSF_CHILDREN),
+static WORD_TRANSF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("armers"),
         dictgen::InsensitiveStr::Ascii("arring"),
@@ -18968,12 +18968,12 @@ pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_TRANSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSE_CHILDREN),
+static WORD_TRANSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("int"),
@@ -18991,12 +18991,12 @@ pub static WORD_TRANSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_TRANSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSC_CHILDREN),
+static WORD_TRANSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -19108,12 +19108,12 @@ pub static WORD_TRANSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=13,
 };
 
-static WORD_TRANSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSA_CHILDREN),
+static WORD_TRANSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -19179,12 +19179,12 @@ pub static WORD_TRANSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_TRANP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANP_CHILDREN),
+static WORD_TRANP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arency"),
         dictgen::InsensitiveStr::Ascii("arent"),
@@ -19216,23 +19216,23 @@ pub static WORD_TRANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANN_CHILDREN),
+static WORD_TRANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sexual")],
     values: &[&["transsexual"]],
     range: 6..=6,
 };
 
-static WORD_TRANM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANM_CHILDREN),
+static WORD_TRANM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ission"),
         dictgen::InsensitiveStr::Ascii("ist"),
@@ -19250,12 +19250,12 @@ pub static WORD_TRANM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRANL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANL_CHILDREN),
+static WORD_TRANL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("astion"),
         dictgen::InsensitiveStr::Ascii("atable"),
@@ -19293,12 +19293,12 @@ pub static WORD_TRANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANI_CHILDREN),
+static WORD_TRANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -19330,23 +19330,23 @@ pub static WORD_TRANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_TRANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANG_CHILDREN),
+static WORD_TRANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("les")],
     values: &[&["triangles"]],
     range: 3..=3,
 };
 
-static WORD_TRANF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANF_CHILDREN),
+static WORD_TRANF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -19382,12 +19382,12 @@ pub static WORD_TRANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_TRAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAND_CHILDREN),
+static WORD_TRAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gender"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -19403,12 +19403,12 @@ pub static WORD_TRAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRANC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANC_CHILDREN),
+static WORD_TRANC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -19436,12 +19436,12 @@ pub static WORD_TRANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_TRANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANA_CHILDREN),
+static WORD_TRANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -19465,12 +19465,12 @@ pub static WORD_TRANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAM_CHILDREN),
+static WORD_TRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("as"),
@@ -19510,12 +19510,12 @@ pub static WORD_TRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_TRAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAL_CHILDREN),
+static WORD_TRAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAL_CHILDREN),
     value: Some(&["trail", "trial"]),
 };
 
-pub static WORD_TRAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ier"),
@@ -19560,12 +19560,12 @@ pub static WORD_TRAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_TRAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAK_CHILDREN),
+static WORD_TRAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAK_CHILDREN),
     value: Some(&["track"]),
 };
 
-pub static WORD_TRAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cers"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -19583,12 +19583,12 @@ pub static WORD_TRAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_TRAJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAJ_CHILDREN),
+static WORD_TRAJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actory"),
         dictgen::InsensitiveStr::Ascii("ecotry"),
@@ -19597,12 +19597,12 @@ pub static WORD_TRAJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_TRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAI_CHILDREN),
+static WORD_TRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ds"),
         dictgen::InsensitiveStr::Ascii("ge"),
@@ -19686,12 +19686,12 @@ pub static WORD_TRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_TRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAG_CHILDREN),
+static WORD_TRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectory"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -19713,12 +19713,12 @@ pub static WORD_TRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TRAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAF_CHILDREN),
+static WORD_TRAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fice"),
         dictgen::InsensitiveStr::Ascii("ficed"),
@@ -19734,12 +19734,12 @@ pub static WORD_TRAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAD_CHILDREN),
+static WORD_TRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dition"),
         dictgen::InsensitiveStr::Ascii("ditional"),
@@ -19783,12 +19783,12 @@ pub static WORD_TRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_TRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAC_CHILDREN),
+static WORD_TRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eablity"),
         dictgen::InsensitiveStr::Ascii("eer"),
@@ -19822,12 +19822,12 @@ pub static WORD_TRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAB_CHILDREN),
+static WORD_TRAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ajao"),
         dictgen::InsensitiveStr::Ascii("ajdo"),
@@ -19837,23 +19837,23 @@ pub static WORD_TRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_TQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TQ_CHILDREN),
+static WORD_TQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rget")],
     values: &[&["target"]],
     range: 4..=4,
 };
 
-static WORD_TP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TP_CHILDREN),
+static WORD_TP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("os"),
@@ -19875,12 +19875,12 @@ pub static WORD_TP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_TO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TO_CHILDREN),
+static WORD_TO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TO_CHILDREN),
     value: None,
 };
 
-static WORD_TO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TOA_NODE),
     Some(&WORD_TOB_NODE),
     Some(&WORD_TOC_NODE),
@@ -19909,12 +19909,12 @@ static WORD_TO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOX_CHILDREN),
+static WORD_TOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("icitity"),
@@ -19925,12 +19925,12 @@ pub static WORD_TOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_TOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOW_CHILDREN),
+static WORD_TOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ords"),
         dictgen::InsensitiveStr::Ascii("rad"),
@@ -19940,12 +19940,12 @@ pub static WORD_TOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_TOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOU_CHILDREN),
+static WORD_TOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOU_CHILDREN),
     value: Some(&["you"]),
 };
 
-pub static WORD_TOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bles"),
@@ -20045,12 +20045,12 @@ pub static WORD_TOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOT_CHILDREN),
+static WORD_TOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alitara"),
         dictgen::InsensitiveStr::Ascii("alitaran"),
@@ -20098,12 +20098,12 @@ pub static WORD_TOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_TOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOS_CHILDREN),
+static WORD_TOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biba"),
         dictgen::InsensitiveStr::Ascii("day"),
@@ -20112,12 +20112,12 @@ pub static WORD_TOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_TOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOR_CHILDREN),
+static WORD_TOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ando"),
         dictgen::InsensitiveStr::Ascii("andoes"),
@@ -20227,12 +20227,12 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOP_CHILDREN),
+static WORD_TOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icaizer"),
         dictgen::InsensitiveStr::Ascii("logical"),
@@ -20262,12 +20262,12 @@ pub static WORD_TOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_TOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOO_CHILDREN),
+static WORD_TOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("gle"),
@@ -20313,12 +20313,12 @@ pub static WORD_TOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TON_CHILDREN),
+static WORD_TON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TON_CHILDREN),
     value: None,
 };
 
-pub static WORD_TON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("giht"),
@@ -20338,12 +20338,12 @@ pub static WORD_TON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_TOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOM_CHILDREN),
+static WORD_TOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arow"),
         dictgen::InsensitiveStr::Ascii("arrow"),
@@ -20397,12 +20397,12 @@ pub static WORD_TOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_TOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOL_CHILDREN),
+static WORD_TOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arable"),
         dictgen::InsensitiveStr::Ascii("earnce"),
@@ -20454,12 +20454,12 @@ pub static WORD_TOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOK_CHILDREN),
+static WORD_TOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enizaing"),
         dictgen::InsensitiveStr::Ascii("enizaiton"),
@@ -20469,23 +20469,23 @@ pub static WORD_TOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_TOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOI_CHILDREN),
+static WORD_TOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOI_CHILDREN),
     value: Some(&["to", "toy"]),
 };
 
-pub static WORD_TOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("letts")],
     values: &[&["toilets"]],
     range: 5..=5,
 };
 
-static WORD_TOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOG_CHILDREN),
+static WORD_TOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ater"),
         dictgen::InsensitiveStr::Ascii("ather"),
@@ -20543,12 +20543,12 @@ pub static WORD_TOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOE_CHILDREN),
+static WORD_TOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kn"),
         dictgen::InsensitiveStr::Ascii("ther"),
@@ -20557,12 +20557,12 @@ pub static WORD_TOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_TOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOD_CHILDREN),
+static WORD_TOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ya"),
@@ -20571,12 +20571,12 @@ pub static WORD_TOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_TOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOC_CHILDREN),
+static WORD_TOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hes"),
         dictgen::InsensitiveStr::Ascii("ksen"),
@@ -20594,12 +20594,12 @@ pub static WORD_TOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_TOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOB_CHILDREN),
+static WORD_TOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baco"),
         dictgen::InsensitiveStr::Ascii("ot"),
@@ -20608,12 +20608,12 @@ pub static WORD_TOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_TOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOA_CHILDREN),
+static WORD_TOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hiba"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -20622,12 +20622,12 @@ pub static WORD_TOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_TN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TN_CHILDREN),
+static WORD_TN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -20636,12 +20636,12 @@ pub static WORD_TN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_TM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TM_CHILDREN),
+static WORD_TM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("is"),
@@ -20651,12 +20651,12 @@ pub static WORD_TM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TL_CHILDREN),
+static WORD_TL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("aking"),
@@ -20665,12 +20665,12 @@ pub static WORD_TL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_TK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TK_CHILDREN),
+static WORD_TK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -20681,12 +20681,12 @@ pub static WORD_TK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_TJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TJ_CHILDREN),
+static WORD_TJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("he"),
@@ -20696,12 +20696,12 @@ pub static WORD_TJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_TI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TI_CHILDREN),
+static WORD_TI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TI_CHILDREN),
     value: None,
 };
 
-static WORD_TI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TIA_NODE),
     Some(&WORD_TIB_NODE),
     Some(&WORD_TIC_NODE),
@@ -20730,23 +20730,23 @@ static WORD_TI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TIW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIW_CHILDREN),
+static WORD_TIW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ards")],
     values: &[&["towards"]],
     range: 4..=4,
 };
 
-static WORD_TIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIT_CHILDREN),
+static WORD_TIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainum"),
         dictgen::InsensitiveStr::Ascii("anim"),
@@ -20770,12 +20770,12 @@ pub static WORD_TIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_TIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIR_CHILDREN),
+static WORD_TIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angle"),
         dictgen::InsensitiveStr::Ascii("angles"),
@@ -20795,12 +20795,12 @@ pub static WORD_TIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_TIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIP_CHILDREN),
+static WORD_TIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -20809,12 +20809,12 @@ pub static WORD_TIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_TIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIO_CHILDREN),
+static WORD_TIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIO_CHILDREN),
     value: Some(&["to"]),
 };
 
-pub static WORD_TIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lets"),
         dictgen::InsensitiveStr::Ascii("me"),
@@ -20823,12 +20823,12 @@ pub static WORD_TIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_TIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIN_CHILDREN),
+static WORD_TIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dergarten"),
         dictgen::InsensitiveStr::Ascii("gs"),
@@ -20838,12 +20838,12 @@ pub static WORD_TIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_TIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIM_CHILDREN),
+static WORD_TIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("delta"),
         dictgen::InsensitiveStr::Ascii("edlta"),
@@ -20943,12 +20943,12 @@ pub static WORD_TIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIL_CHILDREN),
+static WORD_TIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("da"),
         dictgen::InsensitiveStr::Ascii("lt"),
@@ -20959,23 +20959,23 @@ pub static WORD_TIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_TII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TII_CHILDREN),
+static WORD_TII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TII_CHILDREN),
     value: None,
 };
 
-pub static WORD_TII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tle")],
     values: &[&["title"]],
     range: 3..=3,
 };
 
-static WORD_TIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIH_CHILDREN),
+static WORD_TIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kn"),
         dictgen::InsensitiveStr::Ascii("nk"),
@@ -20985,12 +20985,12 @@ pub static WORD_TIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_TIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIG_CHILDREN),
+static WORD_TIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ger"),
         dictgen::InsensitiveStr::Ascii("gered"),
@@ -21034,12 +21034,12 @@ pub static WORD_TIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIE_CHILDREN),
+static WORD_TIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("breakker"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -21065,12 +21065,12 @@ pub static WORD_TIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_TID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TID_CHILDREN),
+static WORD_TID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TID_CHILDREN),
     value: None,
 };
 
-pub static WORD_TID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibt"),
         dictgen::InsensitiveStr::Ascii("ibts"),
@@ -21080,12 +21080,12 @@ pub static WORD_TID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_TIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIC_CHILDREN),
+static WORD_TIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hened"),
@@ -21101,34 +21101,34 @@ pub static WORD_TIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIB_CHILDREN),
+static WORD_TIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etian")],
     values: &[&["tibetan"]],
     range: 5..=5,
 };
 
-static WORD_TIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIA_CHILDREN),
+static WORD_TIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("wanese")],
     values: &[&["taiwanese"]],
     range: 6..=6,
 };
 
-static WORD_TH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TH_CHILDREN),
+static WORD_TH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TH_CHILDREN),
     value: None,
 };
 
-static WORD_TH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_THA_NODE),
     None,
     Some(&WORD_THC_NODE),
@@ -21157,12 +21157,12 @@ static WORD_TH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_THY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THY_CHILDREN),
+static WORD_THY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THY_CHILDREN),
     value: None,
 };
 
-pub static WORD_THY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -21173,23 +21173,23 @@ pub static WORD_THY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_THW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THW_CHILDREN),
+static WORD_THW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THW_CHILDREN),
     value: Some(&["the", "thaw"]),
 };
 
-pub static WORD_THW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["the"]],
     range: 1..=1,
 };
 
-static WORD_THU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THU_CHILDREN),
+static WORD_THU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THU_CHILDREN),
     value: None,
 };
 
-pub static WORD_THU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bmnail"),
         dictgen::InsensitiveStr::Ascii("bmnails"),
@@ -21265,12 +21265,12 @@ pub static WORD_THU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_THT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THT_CHILDREN),
+static WORD_THT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THT_CHILDREN),
     value: Some(&["the", "that"]),
 };
 
-pub static WORD_THT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -21280,12 +21280,12 @@ pub static WORD_THT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_THS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THS_CHILDREN),
+static WORD_THS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THS_CHILDREN),
     value: Some(&["the", "this"]),
 };
 
-pub static WORD_THS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -21321,12 +21321,12 @@ pub static WORD_THS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_THR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_THR_CHILDREN),
+static WORD_THR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_THR_CHILDREN),
     value: Some(&["the"]),
 };
 
-static WORD_THR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_THR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_THRA_NODE),
     None,
     None,
@@ -21355,23 +21355,23 @@ static WORD_THR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_THRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRY_CHILDREN),
+static WORD_THRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oid")],
     values: &[&["thyroid"]],
     range: 3..=3,
 };
 
-static WORD_THRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRU_CHILDREN),
+static WORD_THRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("gh"),
@@ -21395,12 +21395,12 @@ pub static WORD_THRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_THRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRR_CHILDREN),
+static WORD_THRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eshold"),
         dictgen::InsensitiveStr::Ascii("esholds"),
@@ -21409,12 +21409,12 @@ pub static WORD_THRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_THRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRO_CHILDREN),
+static WORD_THRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("aths"),
@@ -21504,12 +21504,12 @@ pub static WORD_THRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_THRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRI_CHILDREN),
+static WORD_THRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dly"),
@@ -21527,12 +21527,12 @@ pub static WORD_THRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_THRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRE_CHILDREN),
+static WORD_THRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRE_CHILDREN),
     value: Some(&["three", "there", "their", "the"]),
 };
 
-pub static WORD_THRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adad"),
         dictgen::InsensitiveStr::Ascii("add"),
@@ -21614,12 +21614,12 @@ pub static WORD_THRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_THRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRA_CHILDREN),
+static WORD_THRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -21628,23 +21628,23 @@ pub static WORD_THRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_THQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THQ_CHILDREN),
+static WORD_THQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THQ_CHILDREN),
     value: Some(&["the"]),
 };
 
-pub static WORD_THQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_THO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THO_CHILDREN),
+static WORD_THO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THO_CHILDREN),
     value: None,
 };
 
-pub static WORD_THO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecracy"),
         dictgen::InsensitiveStr::Ascii("erem"),
@@ -21770,12 +21770,12 @@ pub static WORD_THO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_THN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THN_CHILDREN),
+static WORD_THN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THN_CHILDREN),
     value: Some(&["then"]),
 };
 
-pub static WORD_THN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ak"),
@@ -21799,23 +21799,23 @@ pub static WORD_THN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_THM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THM_CHILDREN),
+static WORD_THM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THM_CHILDREN),
     value: Some(&["them"]),
 };
 
-pub static WORD_THM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["them"]],
     range: 1..=1,
 };
 
-static WORD_THJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THJ_CHILDREN),
+static WORD_THJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_THJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -21824,12 +21824,12 @@ pub static WORD_THJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_THI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THI_CHILDREN),
+static WORD_THI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THI_CHILDREN),
     value: Some(&["the", "this"]),
 };
 
-pub static WORD_THI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aland"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -21945,12 +21945,12 @@ pub static WORD_THI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_THH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THH_CHILDREN),
+static WORD_THH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THH_CHILDREN),
     value: None,
 };
 
-pub static WORD_THH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -21960,12 +21960,12 @@ pub static WORD_THH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_THG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THG_CHILDREN),
+static WORD_THG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THG_CHILDREN),
     value: None,
 };
 
-pub static WORD_THG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -21974,12 +21974,12 @@ pub static WORD_THG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_THE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_THE_CHILDREN),
+static WORD_THE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_THE_CHILDREN),
     value: None,
 };
 
-static WORD_THE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_THE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_THEA_NODE),
     None,
     None,
@@ -22008,12 +22008,12 @@ static WORD_THE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_THEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEY_CHILDREN),
+static WORD_THEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -22022,34 +22022,34 @@ pub static WORD_THEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_THEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEX_CHILDREN),
+static WORD_THEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEX_CHILDREN),
     value: Some(&["the", "then"]),
 };
 
-pub static WORD_THEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_THEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEV_CHILDREN),
+static WORD_THEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEV_CHILDREN),
     value: Some(&["the"]),
 };
 
-pub static WORD_THEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["thieves"]],
     range: 2..=2,
 };
 
-static WORD_THET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THET_CHILDREN),
+static WORD_THET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THET_CHILDREN),
     value: Some(&["that", "the"]),
 };
 
-pub static WORD_THET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ering"),
         dictgen::InsensitiveStr::Ascii("her"),
@@ -22065,12 +22065,12 @@ pub static WORD_THET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_THES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THES_CHILDREN),
+static WORD_THES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THES_CHILDREN),
     value: Some(&["this", "these", "the"]),
 };
 
-pub static WORD_THES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hold"),
         dictgen::InsensitiveStr::Ascii("holds"),
@@ -22090,12 +22090,12 @@ pub static WORD_THES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_THER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_THER_CHILDREN),
+static WORD_THER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_THER_CHILDREN),
     value: Some(&["there", "their", "the", "other"]),
 };
 
-static WORD_THER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_THER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_THERA_NODE),
     Some(&WORD_THERB_NODE),
     None,
@@ -22124,23 +22124,23 @@ static WORD_THER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_THERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERW_CHILDREN),
+static WORD_THERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ise")],
     values: &[&["otherwise"]],
     range: 3..=3,
 };
 
-static WORD_THERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERS_CHILDREN),
+static WORD_THERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hold"),
         dictgen::InsensitiveStr::Ascii("tat"),
@@ -22149,12 +22149,12 @@ pub static WORD_THERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_THERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERO_CHILDREN),
+static WORD_THERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("em"),
         dictgen::InsensitiveStr::Ascii("etical"),
@@ -22184,23 +22184,23 @@ pub static WORD_THERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_THERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERN_CHILDREN),
+static WORD_THERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("odynamics")],
     values: &[&["thermodynamics"]],
     range: 9..=9,
 };
 
-static WORD_THERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERM_CHILDREN),
+static WORD_THERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("astat"),
         dictgen::InsensitiveStr::Ascii("isor"),
@@ -22256,12 +22256,12 @@ pub static WORD_THERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_THERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERI_CHILDREN),
+static WORD_THERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERI_CHILDREN),
     value: Some(&["their", "there"]),
 };
 
-pub static WORD_THERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("pists"),
@@ -22270,23 +22270,23 @@ pub static WORD_THERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_THERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERF_CHILDREN),
+static WORD_THERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ore")],
     values: &[&["therefore"]],
     range: 3..=3,
 };
 
-static WORD_THERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERE_CHILDREN),
+static WORD_THERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("ads"),
@@ -22326,23 +22326,23 @@ pub static WORD_THERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_THERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERB_CHILDREN),
+static WORD_THERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["thereby"]],
     range: 1..=1,
 };
 
-static WORD_THERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERA_CHILDREN),
+static WORD_THERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fter"),
         dictgen::InsensitiveStr::Ascii("min"),
@@ -22374,12 +22374,12 @@ pub static WORD_THERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_THEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEO_CHILDREN),
+static WORD_THEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cracry"),
         dictgen::InsensitiveStr::Ascii("ligical"),
@@ -22429,12 +22429,12 @@ pub static WORD_THEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_THEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEN_CHILDREN),
+static WORD_THEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -22443,12 +22443,12 @@ pub static WORD_THEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_THEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEM_CHILDREN),
+static WORD_THEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eselves"),
         dictgen::InsensitiveStr::Ascii("plate"),
@@ -22484,12 +22484,12 @@ pub static WORD_THEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_THEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEI_CHILDREN),
+static WORD_THEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEI_CHILDREN),
     value: Some(&["their", "they"]),
 };
 
-pub static WORD_THEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("f"),
@@ -22519,23 +22519,23 @@ pub static WORD_THEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_THEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEF_CHILDREN),
+static WORD_THEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ore")],
     values: &[&["therefore"]],
     range: 3..=3,
 };
 
-static WORD_THEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEE_CHILDREN),
+static WORD_THEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -22546,12 +22546,12 @@ pub static WORD_THEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_THEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEA_CHILDREN),
+static WORD_THEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -22581,23 +22581,23 @@ pub static WORD_THEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_THC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THC_CHILDREN),
+static WORD_THC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THC_CHILDREN),
     value: None,
 };
 
-pub static WORD_THC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["thick"]],
     range: 1..=1,
 };
 
-static WORD_THA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THA_CHILDREN),
+static WORD_THA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THA_CHILDREN),
     value: Some(&["than", "that", "the"]),
 };
 
-pub static WORD_THA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -22657,12 +22657,12 @@ pub static WORD_THA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TG_CHILDREN),
+static WORD_TG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -22672,12 +22672,12 @@ pub static WORD_TG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_TE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TE_CHILDREN),
+static WORD_TE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TE_CHILDREN),
     value: None,
 };
 
-static WORD_TE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TEA_NODE),
     None,
     Some(&WORD_TEC_NODE),
@@ -22706,23 +22706,23 @@ static WORD_TE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEY_CHILDREN),
+static WORD_TEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEY_CHILDREN),
     value: Some(&["they"]),
 };
 
-pub static WORD_TEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_TEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEX_CHILDREN),
+static WORD_TEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chnically"),
         dictgen::InsensitiveStr::Ascii("line"),
@@ -22762,12 +22762,12 @@ pub static WORD_TEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_TEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEU_CHILDREN),
+static WORD_TEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sday"),
         dictgen::InsensitiveStr::Ascii("sdays"),
@@ -22776,12 +22776,12 @@ pub static WORD_TEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_TET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TET_CHILDREN),
+static WORD_TET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TET_CHILDREN),
     value: None,
 };
 
-pub static WORD_TET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rahedora"),
         dictgen::InsensitiveStr::Ascii("rahedoren"),
@@ -22809,12 +22809,12 @@ pub static WORD_TET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_TES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TES_CHILDREN),
+static WORD_TES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TES_CHILDREN),
     value: None,
 };
 
-pub static WORD_TES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("case"),
         dictgen::InsensitiveStr::Ascii("cases"),
@@ -22902,12 +22902,12 @@ pub static WORD_TES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TER_CHILDREN),
+static WORD_TER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TER_CHILDREN),
     value: None,
 };
 
-static WORD_TER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TERA_NODE),
     None,
     None,
@@ -22936,12 +22936,12 @@ static WORD_TER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERU_CHILDREN),
+static WORD_TERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rn"),
         dictgen::InsensitiveStr::Ascii("rns"),
@@ -22950,12 +22950,12 @@ pub static WORD_TERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERR_CHILDREN),
+static WORD_TERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("abyte"),
@@ -23057,12 +23057,12 @@ pub static WORD_TERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_TERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERO_CHILDREN),
+static WORD_TERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rrism"),
         dictgen::InsensitiveStr::Ascii("rrist"),
@@ -23072,12 +23072,12 @@ pub static WORD_TERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERN_CHILDREN),
+static WORD_TERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ament"),
         dictgen::InsensitiveStr::Ascii("imate"),
@@ -23093,12 +23093,12 @@ pub static WORD_TERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_TERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TERM_CHILDREN),
+static WORD_TERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TERM_CHILDREN),
     value: None,
 };
 
-static WORD_TERM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TERM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TERMA_NODE),
     None,
     None,
@@ -23127,12 +23127,12 @@ static WORD_TERM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TERMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMP_CHILDREN),
+static WORD_TERMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eratue"),
         dictgen::InsensitiveStr::Ascii("eratues"),
@@ -23162,12 +23162,12 @@ pub static WORD_TERMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_TERMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMO_CHILDREN),
+static WORD_TERMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMO_CHILDREN),
     value: Some(&["thermo"]),
 };
 
-pub static WORD_TERMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nology"),
         dictgen::InsensitiveStr::Ascii("stat"),
@@ -23176,12 +23176,12 @@ pub static WORD_TERMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_TERMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMN_CHILDREN),
+static WORD_TERMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ator"),
         dictgen::InsensitiveStr::Ascii("ials"),
@@ -23211,12 +23211,12 @@ pub static WORD_TERMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_TERMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMI_CHILDREN),
+static WORD_TERMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("als"),
@@ -23300,12 +23300,12 @@ pub static WORD_TERMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TERME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERME_CHILDREN),
+static WORD_TERME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERME_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndous"),
         dictgen::InsensitiveStr::Ascii("ndously"),
@@ -23314,12 +23314,12 @@ pub static WORD_TERME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TERMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMA_CHILDREN),
+static WORD_TERMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nator"),
         dictgen::InsensitiveStr::Ascii("nology"),
@@ -23328,12 +23328,12 @@ pub static WORD_TERMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERI_CHILDREN),
+static WORD_TERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dactyl"),
         dictgen::InsensitiveStr::Ascii("fic"),
@@ -23353,12 +23353,12 @@ pub static WORD_TERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_TERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERF_CHILDREN),
+static WORD_TERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("formed"),
@@ -23374,23 +23374,23 @@ pub static WORD_TERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_TERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERE_CHILDREN),
+static WORD_TERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERE_CHILDREN),
     value: Some(&["there", "here"]),
 };
 
-pub static WORD_TERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_TERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERA_CHILDREN),
+static WORD_TERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("formed"),
@@ -23408,12 +23408,12 @@ pub static WORD_TERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_TEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEQ_CHILDREN),
+static WORD_TEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uests"),
         dictgen::InsensitiveStr::Ascii("uilia"),
@@ -23423,12 +23423,12 @@ pub static WORD_TEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_TEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEP_CHILDREN),
+static WORD_TEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lmate"),
         dictgen::InsensitiveStr::Ascii("lmated"),
@@ -23446,23 +23446,23 @@ pub static WORD_TEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_TEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEO_CHILDREN),
+static WORD_TEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rem")],
     values: &[&["theorem"]],
     range: 3..=3,
 };
 
-static WORD_TEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEN_CHILDREN),
+static WORD_TEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acitiy"),
         dictgen::InsensitiveStr::Ascii("acle"),
@@ -23544,12 +23544,12 @@ pub static WORD_TEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_TEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TEM_CHILDREN),
+static WORD_TEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TEM_CHILDREN),
     value: None,
 };
 
-static WORD_TEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TEM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TEMA_NODE),
     None,
     None,
@@ -23578,45 +23578,45 @@ static WORD_TEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TEMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMT_CHILDREN),
+static WORD_TEMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["temptation"]],
     range: 5..=5,
 };
 
-static WORD_TEMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMS_CHILDREN),
+static WORD_TEMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("elves")],
     values: &[&["themselves"]],
     range: 5..=5,
 };
 
-static WORD_TEMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMR_CHILDREN),
+static WORD_TEMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMR_CHILDREN),
     value: Some(&["term"]),
 };
 
-pub static WORD_TEMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inal")],
     values: &[&["terminal"]],
     range: 4..=4,
 };
 
-static WORD_TEMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TEMP_CHILDREN),
+static WORD_TEMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TEMP_CHILDREN),
     value: None,
 };
 
-static WORD_TEMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TEMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TEMPA_NODE),
     None,
     None,
@@ -23645,12 +23645,12 @@ static WORD_TEMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TEMPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPU_CHILDREN),
+static WORD_TEMPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rature"),
         dictgen::InsensitiveStr::Ascii("ratures"),
@@ -23660,12 +23660,12 @@ pub static WORD_TEMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TEMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPT_CHILDREN),
+static WORD_TEMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atation"),
         dictgen::InsensitiveStr::Ascii("ating"),
@@ -23681,23 +23681,23 @@ pub static WORD_TEMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TEMPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPS_CHILDREN),
+static WORD_TEMPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["tempest"]],
     range: 2..=2,
 };
 
-static WORD_TEMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPR_CHILDREN),
+static WORD_TEMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aaily"),
         dictgen::InsensitiveStr::Ascii("aal"),
@@ -23797,12 +23797,12 @@ pub static WORD_TEMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TEMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPO_CHILDREN),
+static WORD_TEMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aray"),
         dictgen::InsensitiveStr::Ascii("pary"),
@@ -23898,12 +23898,12 @@ pub static WORD_TEMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_TEMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPL_CHILDREN),
+static WORD_TEMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aced"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -23949,12 +23949,12 @@ pub static WORD_TEMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_TEMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPE_CHILDREN),
+static WORD_TEMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arture"),
         dictgen::InsensitiveStr::Ascii("artures"),
@@ -24008,23 +24008,23 @@ pub static WORD_TEMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TEMPD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPD_CHILDREN),
+static WORD_TEMPD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ate")],
     values: &[&["template"]],
     range: 3..=3,
 };
 
-static WORD_TEMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPA_CHILDREN),
+static WORD_TEMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lrs"),
         dictgen::InsensitiveStr::Ascii("lte"),
@@ -24074,12 +24074,12 @@ pub static WORD_TEMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TEMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMO_CHILDREN),
+static WORD_TEMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rarily"),
         dictgen::InsensitiveStr::Ascii("rary"),
@@ -24088,34 +24088,34 @@ pub static WORD_TEMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_TEMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMM_CHILDREN),
+static WORD_TEMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("porary")],
     values: &[&["temporary", "temporarily"]],
     range: 6..=6,
 };
 
-static WORD_TEML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEML_CHILDREN),
+static WORD_TEML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEML_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ate")],
     values: &[&["template"]],
     range: 3..=3,
 };
 
-static WORD_TEMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMI_CHILDREN),
+static WORD_TEMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nal"),
         dictgen::InsensitiveStr::Ascii("nals"),
@@ -24137,12 +24137,12 @@ pub static WORD_TEMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_TEME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEME_CHILDREN),
+static WORD_TEME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEME_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("prature"),
         dictgen::InsensitiveStr::Ascii("pratures"),
@@ -24158,12 +24158,12 @@ pub static WORD_TEME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_TEMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMA_CHILDREN),
+static WORD_TEMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMA_CHILDREN),
     value: Some(&["team"]),
 };
 
-pub static WORD_TEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fight"),
         dictgen::InsensitiveStr::Ascii("fights"),
@@ -24179,12 +24179,12 @@ pub static WORD_TEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEL_CHILDREN),
+static WORD_TEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aportation"),
         dictgen::InsensitiveStr::Ascii("egrah"),
@@ -24248,12 +24248,12 @@ pub static WORD_TEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_TEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEK_CHILDREN),
+static WORD_TEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("st"),
@@ -24263,12 +24263,12 @@ pub static WORD_TEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_TEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEH_CHILDREN),
+static WORD_TEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEH_CHILDREN),
     value: Some(&["the"]),
 };
 
-pub static WORD_TEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cies"),
         dictgen::InsensitiveStr::Ascii("ere"),
@@ -24298,34 +24298,34 @@ pub static WORD_TEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEG_CHILDREN),
+static WORD_TEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ister")],
     values: &[&["register"]],
     range: 5..=5,
 };
 
-static WORD_TEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEF_CHILDREN),
+static WORD_TEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ine")],
     values: &[&["define"]],
     range: 3..=3,
 };
 
-static WORD_TEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEE_CHILDREN),
+static WORD_TEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angers"),
         dictgen::InsensitiveStr::Ascii("nages"),
@@ -24343,23 +24343,23 @@ pub static WORD_TEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_TED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TED_CHILDREN),
+static WORD_TED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TED_CHILDREN),
     value: None,
 };
 
-pub static WORD_TED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eous")],
     values: &[&["tedious"]],
     range: 4..=4,
 };
 
-static WORD_TEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TEC_CHILDREN),
+static WORD_TEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TEC_CHILDREN),
     value: None,
 };
 
-static WORD_TEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -24388,23 +24388,23 @@ static WORD_TEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECT_CHILDREN),
+static WORD_TECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECT_CHILDREN),
     value: Some(&["test", "text"]),
 };
 
-pub static WORD_TECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ure")],
     values: &[&["texture"]],
     range: 3..=3,
 };
 
-static WORD_TECN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECN_CHILDREN),
+static WORD_TECN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -24428,12 +24428,12 @@ pub static WORD_TECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TECH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TECH_CHILDREN),
+static WORD_TECH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TECH_CHILDREN),
     value: None,
 };
 
-static WORD_TECH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TECH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TECHA_NODE),
     None,
     None,
@@ -24462,12 +24462,12 @@ static WORD_TECH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TECHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHT_CHILDREN),
+static WORD_TECHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ician"),
         dictgen::InsensitiveStr::Ascii("icians"),
@@ -24476,12 +24476,12 @@ pub static WORD_TECHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TECHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHO_CHILDREN),
+static WORD_TECHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logy"),
         dictgen::InsensitiveStr::Ascii("nlogical"),
@@ -24491,12 +24491,12 @@ pub static WORD_TECHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_TECHN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHN_CHILDREN),
+static WORD_TECHN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cially"),
         dictgen::InsensitiveStr::Ascii("eek"),
@@ -24582,23 +24582,23 @@ pub static WORD_TECHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_TECHM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHM_CHILDREN),
+static WORD_TECHM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ological")],
     values: &[&["technological"]],
     range: 8..=8,
 };
 
-static WORD_TECHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHI_CHILDREN),
+static WORD_TECHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("cally"),
@@ -24644,12 +24644,12 @@ pub static WORD_TECHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TECHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHE_CHILDREN),
+static WORD_TECHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("is"),
@@ -24667,23 +24667,23 @@ pub static WORD_TECHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_TECHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHA_CHILDREN),
+static WORD_TECHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nically")],
     values: &[&["mechanically"]],
     range: 7..=7,
 };
 
-static WORD_TEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEA_CHILDREN),
+static WORD_TEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cer"),
         dictgen::InsensitiveStr::Ascii("cers"),
@@ -24751,12 +24751,12 @@ pub static WORD_TEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_TD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TD_CHILDREN),
+static WORD_TD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("od"),
         dictgen::InsensitiveStr::Ascii("oo"),
@@ -24765,12 +24765,12 @@ pub static WORD_TD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_TC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TC_CHILDREN),
+static WORD_TC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahce"),
         dictgen::InsensitiveStr::Ascii("ahces"),
@@ -24790,12 +24790,12 @@ pub static WORD_TC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_TB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TB_CHILDREN),
+static WORD_TB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ey"),
@@ -24804,12 +24804,12 @@ pub static WORD_TB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_TA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TA_CHILDREN),
+static WORD_TA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TA_CHILDREN),
     value: None,
 };
 
-static WORD_TA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_TAB_NODE),
     Some(&WORD_TAC_NODE),
@@ -24838,23 +24838,23 @@ static WORD_TA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAY_CHILDREN),
+static WORD_TAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lored")],
     values: &[&["tailored"]],
     range: 5..=5,
 };
 
-static WORD_TAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAX_CHILDREN),
+static WORD_TAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anomic"),
         dictgen::InsensitiveStr::Ascii("anomy"),
@@ -24874,12 +24874,12 @@ pub static WORD_TAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_TAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAW_CHILDREN),
+static WORD_TAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainese"),
         dictgen::InsensitiveStr::Ascii("ianese"),
@@ -24889,12 +24889,12 @@ pub static WORD_TAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_TAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAV_CHILDREN),
+static WORD_TAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -24910,12 +24910,12 @@ pub static WORD_TAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_TAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAT_CHILDREN),
+static WORD_TAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gert"),
         dictgen::InsensitiveStr::Ascii("gerted"),
@@ -24943,12 +24943,12 @@ pub static WORD_TAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAS_CHILDREN),
+static WORD_TAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bar"),
         dictgen::InsensitiveStr::Ascii("kelt"),
@@ -24964,12 +24964,12 @@ pub static WORD_TAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAR_CHILDREN),
+static WORD_TAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bal"),
         dictgen::InsensitiveStr::Ascii("bals"),
@@ -25033,23 +25033,23 @@ pub static WORD_TAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAP_CHILDREN),
+static WORD_TAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itude")],
     values: &[&["aptitude"]],
     range: 5..=5,
 };
 
-static WORD_TAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAN_CHILDREN),
+static WORD_TAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enhill"),
         dictgen::InsensitiveStr::Ascii("geant"),
@@ -25131,12 +25131,12 @@ pub static WORD_TAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_TAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAM_CHILDREN),
+static WORD_TAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("plate"),
         dictgen::InsensitiveStr::Ascii("plated"),
@@ -25152,12 +25152,12 @@ pub static WORD_TAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_TAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAL_CHILDREN),
+static WORD_TAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("bian"),
@@ -25187,12 +25187,12 @@ pub static WORD_TAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_TAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAK_CHILDREN),
+static WORD_TAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAK_CHILDREN),
     value: Some(&["take"]),
 };
 
-pub static WORD_TAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -25210,12 +25210,12 @@ pub static WORD_TAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_TAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAI_CHILDREN),
+static WORD_TAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lban"),
         dictgen::InsensitiveStr::Ascii("lgateing"),
@@ -25241,12 +25241,12 @@ pub static WORD_TAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAH_CHILDREN),
+static WORD_TAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nk"),
@@ -25258,12 +25258,12 @@ pub static WORD_TAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAG_CHILDREN),
+static WORD_TAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -25303,12 +25303,12 @@ pub static WORD_TAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_TAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAC_CHILDREN),
+static WORD_TAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itcally"),
         dictgen::InsensitiveStr::Ascii("ticallity"),
@@ -25328,12 +25328,12 @@ pub static WORD_TAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_TAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAB_CHILDREN),
+static WORD_TAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acco"),
         dictgen::InsensitiveStr::Ascii("baray"),
@@ -25411,12 +25411,12 @@ pub static WORD_TAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_S_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_S_CHILDREN),
+static WORD_S_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_S_CHILDREN),
     value: None,
 };
 
-static WORD_S_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_S_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SA_NODE),
     Some(&WORD_SB_NODE),
     Some(&WORD_SC_NODE),
@@ -25445,12 +25445,12 @@ static WORD_S_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SZ_NODE),
 ];
 
-static WORD_SZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SZ_CHILDREN),
+static WORD_SZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enario"),
         dictgen::InsensitiveStr::Ascii("enarios"),
@@ -25470,12 +25470,12 @@ pub static WORD_SZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SY_CHILDREN),
+static WORD_SY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SY_CHILDREN),
     value: None,
 };
 
-static WORD_SY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SY_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SYA_NODE),
     Some(&WORD_SYB_NODE),
     Some(&WORD_SYC_NODE),
@@ -25504,12 +25504,12 @@ static WORD_SY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SYT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYT_CHILDREN),
+static WORD_SYT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actical"),
         dictgen::InsensitiveStr::Ascii("ax"),
@@ -25573,12 +25573,12 @@ pub static WORD_SYT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SYS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYS_CHILDREN),
+static WORD_SYS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("admn"),
         dictgen::InsensitiveStr::Ascii("amdin"),
@@ -25676,12 +25676,12 @@ pub static WORD_SYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_SYR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYR_CHILDREN),
+static WORD_SYR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acue"),
         dictgen::InsensitiveStr::Ascii("acusae"),
@@ -25705,12 +25705,12 @@ pub static WORD_SYR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SYP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYP_CHILDREN),
+static WORD_SYP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hyllis"),
         dictgen::InsensitiveStr::Ascii("mathetic"),
@@ -25734,12 +25734,12 @@ pub static WORD_SYP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_SYN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SYN_CHILDREN),
+static WORD_SYN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SYN_CHILDREN),
     value: None,
 };
 
-static WORD_SYN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SYN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SYNA_NODE),
     Some(&WORD_SYNB_NODE),
     Some(&WORD_SYNC_NODE),
@@ -25768,12 +25768,12 @@ static WORD_SYN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SYNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNT_CHILDREN),
+static WORD_SYNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ac"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -25861,23 +25861,23 @@ pub static WORD_SYNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SYNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNR_CHILDREN),
+static WORD_SYNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onous")],
     values: &[&["synchronous"]],
     range: 5..=5,
 };
 
-static WORD_SYNP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNP_CHILDREN),
+static WORD_SYNP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hony"),
         dictgen::InsensitiveStr::Ascii("osis"),
@@ -25886,12 +25886,12 @@ pub static WORD_SYNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_SYNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNO_CHILDREN),
+static WORD_SYNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mym"),
         dictgen::InsensitiveStr::Ascii("mymous"),
@@ -25947,34 +25947,34 @@ pub static WORD_SYNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SYNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNI_CHILDREN),
+static WORD_SYNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dcate")],
     values: &[&["syndicate"]],
     range: 5..=5,
 };
 
-static WORD_SYNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNE_CHILDREN),
+static WORD_SYNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gry")],
     values: &[&["synergy"]],
     range: 3..=3,
 };
 
-static WORD_SYND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYND_CHILDREN),
+static WORD_SYND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYND_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acite"),
         dictgen::InsensitiveStr::Ascii("iacte"),
@@ -25992,12 +25992,12 @@ pub static WORD_SYND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SYNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNC_CHILDREN),
+static WORD_SYNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("honisation"),
         dictgen::InsensitiveStr::Ascii("honise"),
@@ -26115,23 +26115,23 @@ pub static WORD_SYNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_SYNB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNB_CHILDREN),
+static WORD_SYNB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olic")],
     values: &[&["symbolic"]],
     range: 4..=4,
 };
 
-static WORD_SYNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNA_CHILDREN),
+static WORD_SYNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gouge"),
         dictgen::InsensitiveStr::Ascii("mic"),
@@ -26149,12 +26149,12 @@ pub static WORD_SYNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SYM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SYM_CHILDREN),
+static WORD_SYM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SYM_CHILDREN),
     value: None,
 };
 
-static WORD_SYM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SYM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SYMA_NODE),
     Some(&WORD_SYMB_NODE),
     None,
@@ -26183,12 +26183,12 @@ static WORD_SYM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SYMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMT_CHILDREN),
+static WORD_SYMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oms"),
         dictgen::InsensitiveStr::Ascii("pom"),
@@ -26198,12 +26198,12 @@ pub static WORD_SYMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SYMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMP_CHILDREN),
+static WORD_SYMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("athatic"),
         dictgen::InsensitiveStr::Ascii("atheic"),
@@ -26291,12 +26291,12 @@ pub static WORD_SYMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_SYMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMO_CHILDREN),
+static WORD_SYMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilic"),
         dictgen::InsensitiveStr::Ascii("bl"),
@@ -26324,12 +26324,12 @@ pub static WORD_SYMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SYMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMN_CHILDREN),
+static WORD_SYMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ol"),
         dictgen::InsensitiveStr::Ascii("ols"),
@@ -26338,12 +26338,12 @@ pub static WORD_SYMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SYMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMM_CHILDREN),
+static WORD_SYMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ertical"),
         dictgen::InsensitiveStr::Ascii("erty"),
@@ -26369,23 +26369,23 @@ pub static WORD_SYMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SYMH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMH_CHILDREN),
+static WORD_SYMH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pony")],
     values: &[&["symphony"]],
     range: 4..=4,
 };
 
-static WORD_SYME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYME_CHILDREN),
+static WORD_SYME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYME_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("metric"),
         dictgen::InsensitiveStr::Ascii("tri"),
@@ -26407,12 +26407,12 @@ pub static WORD_SYME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SYMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMB_CHILDREN),
+static WORD_SYMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("les"),
@@ -26446,12 +26446,12 @@ pub static WORD_SYMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SYMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMA_CHILDREN),
+static WORD_SYMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntic"),
         dictgen::InsensitiveStr::Ascii("ntics"),
@@ -26471,12 +26471,12 @@ pub static WORD_SYMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_SYL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYL_CHILDREN),
+static WORD_SYL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ablle"),
         dictgen::InsensitiveStr::Ascii("ablles"),
@@ -26514,12 +26514,12 @@ pub static WORD_SYL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SYK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYK_CHILDREN),
+static WORD_SYK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("walker"),
         dictgen::InsensitiveStr::Ascii("ward"),
@@ -26528,34 +26528,34 @@ pub static WORD_SYK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_SYI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYI_CHILDREN),
+static WORD_SYI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rans")],
     values: &[&["syrians"]],
     range: 4..=4,
 };
 
-static WORD_SYF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYF_CHILDREN),
+static WORD_SYF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["sysfs"]],
     range: 1..=1,
 };
 
-static WORD_SYD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYD_CHILDREN),
+static WORD_SYD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nicate"),
         dictgen::InsensitiveStr::Ascii("nrome"),
@@ -26564,12 +26564,12 @@ pub static WORD_SYD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_SYC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYC_CHILDREN),
+static WORD_SYC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hnronization"),
         dictgen::InsensitiveStr::Ascii("hronisation"),
@@ -26655,12 +26655,12 @@ pub static WORD_SYC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_SYB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYB_CHILDREN),
+static WORD_SYB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mols"),
         dictgen::InsensitiveStr::Ascii("system"),
@@ -26670,12 +26670,12 @@ pub static WORD_SYB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SYA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYA_CHILDREN),
+static WORD_SYA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntax"),
         dictgen::InsensitiveStr::Ascii("rcuse"),
@@ -26693,12 +26693,12 @@ pub static WORD_SYA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SX_CHILDREN),
+static WORD_SX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("mbol"),
@@ -26709,12 +26709,12 @@ pub static WORD_SX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SW_CHILDREN),
+static WORD_SW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SW_CHILDREN),
     value: None,
 };
 
-static WORD_SW_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SW_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SWA_NODE),
     None,
     Some(&WORD_SWC_NODE),
@@ -26743,12 +26743,12 @@ static WORD_SW_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SWT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWT_CHILDREN),
+static WORD_SWT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ich"),
         dictgen::InsensitiveStr::Ascii("ichable"),
@@ -26784,34 +26784,34 @@ pub static WORD_SWT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SWO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWO_CHILDREN),
+static WORD_SWO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("wn")],
     values: &[&["shown"]],
     range: 2..=2,
 };
 
-static WORD_SWN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWN_CHILDREN),
+static WORD_SWN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("asea")],
     values: &[&["swansea"]],
     range: 4..=4,
 };
 
-static WORD_SWI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWI_CHILDREN),
+static WORD_SWI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -26895,12 +26895,12 @@ pub static WORD_SWI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SWE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWE_CHILDREN),
+static WORD_SWE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arengin"),
         dictgen::InsensitiveStr::Ascii("arshirt"),
@@ -26934,23 +26934,23 @@ pub static WORD_SWE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_SWC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWC_CHILDREN),
+static WORD_SWC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("loumns")],
     values: &[&["swcolumns"]],
     range: 6..=6,
 };
 
-static WORD_SWA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWA_CHILDREN),
+static WORD_SWA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ering"),
@@ -26990,12 +26990,12 @@ pub static WORD_SWA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SV_CHILDREN),
+static WORD_SV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("elt"),
@@ -27004,12 +27004,12 @@ pub static WORD_SV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_SU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SU_CHILDREN),
+static WORD_SU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SU_CHILDREN),
     value: None,
 };
 
-static WORD_SU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SUA_NODE),
     Some(&WORD_SUB_NODE),
     Some(&WORD_SUC_NODE),
@@ -27038,12 +27038,12 @@ static WORD_SU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUY_CHILDREN),
+static WORD_SUY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stem"),
         dictgen::InsensitiveStr::Ascii("stemic"),
@@ -27053,12 +27053,12 @@ pub static WORD_SUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_SUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUV_CHILDREN),
+static WORD_SUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enear"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -27067,12 +27067,12 @@ pub static WORD_SUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUU_CHILDREN),
+static WORD_SUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("port"),
         dictgen::InsensitiveStr::Ascii("ported"),
@@ -27083,12 +27083,12 @@ pub static WORD_SUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUT_CHILDREN),
+static WORD_SUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("down"),
@@ -27126,12 +27126,12 @@ pub static WORD_SUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_SUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUS_CHILDREN),
+static WORD_SUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUS_CHILDREN),
     value: None,
 };
 
-static WORD_SUS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SUSB_NODE),
     Some(&WORD_SUSC_NODE),
@@ -27160,23 +27160,23 @@ static WORD_SUS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSU_CHILDREN),
+static WORD_SUSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pend")],
     values: &[&["suspend"]],
     range: 4..=4,
 };
 
-static WORD_SUST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUST_CHILDREN),
+static WORD_SUST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUST_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainabillity"),
         dictgen::InsensitiveStr::Ascii("ainabiltiy"),
@@ -27206,12 +27206,12 @@ pub static WORD_SUST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_SUSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSS_CHILDREN),
+static WORD_SUSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eed"),
         dictgen::InsensitiveStr::Ascii("eeded"),
@@ -27233,12 +27233,12 @@ pub static WORD_SUSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SUSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSP_CHILDREN),
+static WORD_SUSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciously"),
         dictgen::InsensitiveStr::Ascii("ecions"),
@@ -27324,23 +27324,23 @@ pub static WORD_SUSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUSN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSN_CHILDREN),
+static WORD_SUSN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("creen")],
     values: &[&["sunscreen"]],
     range: 5..=5,
 };
 
-static WORD_SUSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSI_CHILDREN),
+static WORD_SUSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nct"),
         dictgen::InsensitiveStr::Ascii("nctly"),
@@ -27350,12 +27350,12 @@ pub static WORD_SUSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SUSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSE_CHILDREN),
+static WORD_SUSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cptible"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -27387,12 +27387,12 @@ pub static WORD_SUSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SUSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSC_CHILDREN),
+static WORD_SUSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ede"),
         dictgen::InsensitiveStr::Ascii("eded"),
@@ -27430,12 +27430,12 @@ pub static WORD_SUSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUSB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSB_CHILDREN),
+static WORD_SUSB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cribe"),
         dictgen::InsensitiveStr::Ascii("cribed"),
@@ -27463,12 +27463,12 @@ pub static WORD_SUSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_SUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUR_CHILDREN),
+static WORD_SUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUR_CHILDREN),
     value: Some(&["sure"]),
 };
 
-static WORD_SUR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SURB_NODE),
     None,
@@ -27497,12 +27497,12 @@ static WORD_SUR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SURV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURV_CHILDREN),
+static WORD_SURV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aillance"),
         dictgen::InsensitiveStr::Ascii("aillence"),
@@ -27576,12 +27576,12 @@ pub static WORD_SURV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SURR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURR_CHILDREN),
+static WORD_SURR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egat"),
         dictgen::InsensitiveStr::Ascii("ended"),
@@ -27643,12 +27643,12 @@ pub static WORD_SURR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_SURP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURP_CHILDREN),
+static WORD_SURP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ases"),
         dictgen::InsensitiveStr::Ascii("emacist"),
@@ -27696,12 +27696,12 @@ pub static WORD_SURP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SURO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURO_CHILDREN),
+static WORD_SURO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("und"),
         dictgen::InsensitiveStr::Ascii("unded"),
@@ -27719,23 +27719,23 @@ pub static WORD_SURO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SURL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURL_CHILDREN),
+static WORD_SURL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ey")],
     values: &[&["surly", "surely"]],
     range: 2..=2,
 };
 
-static WORD_SURG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURG_CHILDREN),
+static WORD_SURG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ested"),
@@ -27757,12 +27757,12 @@ pub static WORD_SURG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SURF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURF_CHILDREN),
+static WORD_SURF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aec"),
         dictgen::InsensitiveStr::Ascii("cae"),
@@ -27772,23 +27772,23 @@ pub static WORD_SURF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SURE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURE_CHILDREN),
+static WORD_SURE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("vy")],
     values: &[&["survey"]],
     range: 2..=2,
 };
 
-static WORD_SURB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURB_CHILDREN),
+static WORD_SURB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ert"),
         dictgen::InsensitiveStr::Ascii("uban"),
@@ -27797,12 +27797,12 @@ pub static WORD_SURB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUP_CHILDREN),
+static WORD_SUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUP_CHILDREN),
     value: None,
 };
 
-static WORD_SUP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -27831,12 +27831,12 @@ static WORD_SUP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPS_CHILDREN),
+static WORD_SUPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cription"),
         dictgen::InsensitiveStr::Ascii("criptions"),
@@ -27874,12 +27874,12 @@ pub static WORD_SUPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SUPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPR_CHILDREN),
+static WORD_SUPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amacist"),
         dictgen::InsensitiveStr::Ascii("ass"),
@@ -27957,12 +27957,12 @@ pub static WORD_SUPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SUPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUPP_CHILDREN),
+static WORD_SUPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUPP_CHILDREN),
     value: None,
 };
 
-static WORD_SUPP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUPP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -27991,23 +27991,23 @@ static WORD_SUPP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUPPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPY_CHILDREN),
+static WORD_SUPPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPY_CHILDREN),
     value: Some(&["supply"]),
 };
 
-pub static WORD_SUPPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["supplying"]],
     range: 3..=3,
 };
 
-static WORD_SUPPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPU_CHILDREN),
+static WORD_SUPPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rt"),
         dictgen::InsensitiveStr::Ascii("rted"),
@@ -28029,12 +28029,12 @@ pub static WORD_SUPPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SUPPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPR_CHILDREN),
+static WORD_SUPPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("esed"),
@@ -28092,12 +28092,12 @@ pub static WORD_SUPPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SUPPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPP_CHILDREN),
+static WORD_SUPPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lied"),
         dictgen::InsensitiveStr::Ascii("ored"),
@@ -28123,12 +28123,12 @@ pub static WORD_SUPPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SUPPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPO_CHILDREN),
+static WORD_SUPPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ert"),
@@ -28220,12 +28220,12 @@ pub static WORD_SUPPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SUPPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPL_CHILDREN),
+static WORD_SUPPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ament"),
         dictgen::InsensitiveStr::Ascii("amental"),
@@ -28263,12 +28263,12 @@ pub static WORD_SUPPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SUPPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPI_CHILDREN),
+static WORD_SUPPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -28278,12 +28278,12 @@ pub static WORD_SUPPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=2,
 };
 
-static WORD_SUPPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPE_CHILDREN),
+static WORD_SUPPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rssor"),
         dictgen::InsensitiveStr::Ascii("rt"),
@@ -28293,12 +28293,12 @@ pub static WORD_SUPPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SUPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPO_CHILDREN),
+static WORD_SUPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("orted"),
@@ -28346,12 +28346,12 @@ pub static WORD_SUPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SUPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPL_CHILDREN),
+static WORD_SUPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("anted"),
@@ -28379,34 +28379,34 @@ pub static WORD_SUPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPI_CHILDREN),
+static WORD_SUPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rsed")],
     values: &[&["surprised"]],
     range: 4..=4,
 };
 
-static WORD_SUPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPH_CHILDREN),
+static WORD_SUPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("isticated")],
     values: &[&["sophisticated"]],
     range: 9..=9,
 };
 
-static WORD_SUPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUPE_CHILDREN),
+static WORD_SUPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUPE_CHILDREN),
     value: None,
 };
 
-static WORD_SUPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SUPEB_NODE),
     Some(&WORD_SUPEC_NODE),
@@ -28435,12 +28435,12 @@ static WORD_SUPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUPER_CHILDREN),
+static WORD_SUPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUPER_CHILDREN),
     value: None,
 };
 
-static WORD_SUPER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUPER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SUPERB_NODE),
     Some(&WORD_SUPERC_NODE),
@@ -28469,12 +28469,12 @@ static WORD_SUPER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUPERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERV_CHILDREN),
+static WORD_SUPERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iors"),
         dictgen::InsensitiveStr::Ascii("iosr"),
@@ -28508,12 +28508,12 @@ pub static WORD_SUPERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_SUPERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERS_CHILDREN),
+static WORD_SUPERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eed"),
@@ -28557,12 +28557,12 @@ pub static WORD_SUPERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_SUPERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERP_CHILDREN),
+static WORD_SUPERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oser"),
         dictgen::InsensitiveStr::Ascii("owereds"),
@@ -28571,12 +28571,12 @@ pub static WORD_SUPERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_SUPERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERO_CHILDREN),
+static WORD_SUPERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("peator"),
         dictgen::InsensitiveStr::Ascii("uman"),
@@ -28585,12 +28585,12 @@ pub static WORD_SUPERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_SUPERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERN_CHILDREN),
+static WORD_SUPERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arkets"),
         dictgen::InsensitiveStr::Ascii("atrual"),
@@ -28600,12 +28600,12 @@ pub static WORD_SUPERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_SUPERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERM_CHILDREN),
+static WORD_SUPERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acist"),
         dictgen::InsensitiveStr::Ascii("akert"),
@@ -28647,12 +28647,12 @@ pub static WORD_SUPERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_SUPERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERI_CHILDREN),
+static WORD_SUPERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fical"),
         dictgen::InsensitiveStr::Ascii("ntendant"),
@@ -28680,12 +28680,12 @@ pub static WORD_SUPERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_SUPERH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERH_CHILDREN),
+static WORD_SUPERH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("eo"),
@@ -28695,12 +28695,12 @@ pub static WORD_SUPERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_SUPERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERF_CHILDREN),
+static WORD_SUPERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("iciel"),
@@ -28726,12 +28726,12 @@ pub static WORD_SUPERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_SUPERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERC_CHILDREN),
+static WORD_SUPERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alifragilisticexpialidoceous"),
         dictgen::InsensitiveStr::Ascii("ede"),
@@ -28757,12 +28757,12 @@ pub static WORD_SUPERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=28,
 };
 
-static WORD_SUPERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERB_CHILDREN),
+static WORD_SUPERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ock"),
         dictgen::InsensitiveStr::Ascii("ocks"),
@@ -28771,56 +28771,56 @@ pub static WORD_SUPERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_SUPEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPEE_CHILDREN),
+static WORD_SUPEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("na")],
     values: &[&["subpoena"]],
     range: 2..=2,
 };
 
-static WORD_SUPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPEC_CHILDREN),
+static WORD_SUPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["suspected"]],
     range: 3..=3,
 };
 
-static WORD_SUPEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPEB_CHILDREN),
+static WORD_SUPEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lock")],
     values: &[&["superblock"]],
     range: 4..=4,
 };
 
-static WORD_SUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUO_CHILDREN),
+static WORD_SUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("p")],
     values: &[&["soup"]],
     range: 1..=1,
 };
 
-static WORD_SUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUN_CHILDREN),
+static WORD_SUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("binterpreter"),
         dictgen::InsensitiveStr::Ascii("conscious"),
@@ -28866,12 +28866,12 @@ pub static WORD_SUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_SUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUM_CHILDREN),
+static WORD_SUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amrize"),
         dictgen::InsensitiveStr::Ascii("amry"),
@@ -28973,23 +28973,23 @@ pub static WORD_SUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_SUJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUJ_CHILDREN),
+static WORD_SUJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ect")],
     values: &[&["subject"]],
     range: 3..=3,
 };
 
-static WORD_SUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUI_CHILDREN),
+static WORD_SUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ete"),
         dictgen::InsensitiveStr::Ascii("tablity"),
@@ -28999,23 +28999,23 @@ pub static WORD_SUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_SUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUH_CHILDREN),
+static WORD_SUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUH_CHILDREN),
     value: Some(&["such"]),
 };
 
-pub static WORD_SUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUG_CHILDREN),
+static WORD_SUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ery"),
@@ -29113,12 +29113,12 @@ pub static WORD_SUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_SUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUF_CHILDREN),
+static WORD_SUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -29216,12 +29216,12 @@ pub static WORD_SUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUE_CHILDREN),
+static WORD_SUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ful"),
         dictgen::InsensitiveStr::Ascii("full"),
@@ -29231,12 +29231,12 @@ pub static WORD_SUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_SUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUD_CHILDREN),
+static WORD_SUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dently"),
         dictgen::InsensitiveStr::Ascii("deny"),
@@ -29268,12 +29268,12 @@ pub static WORD_SUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUC_CHILDREN),
+static WORD_SUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUC_CHILDREN),
     value: None,
 };
 
-static WORD_SUC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_SUCC_NODE),
@@ -29302,12 +29302,12 @@ static WORD_SUC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCS_CHILDREN),
+static WORD_SUCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ede"),
         dictgen::InsensitiveStr::Ascii("eptible"),
@@ -29323,23 +29323,23 @@ pub static WORD_SUCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCO_CHILDREN),
+static WORD_SUCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("me")],
     values: &[&["succumb"]],
     range: 2..=2,
 };
 
-static WORD_SUCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCI_CHILDREN),
+static WORD_SUCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("dial"),
@@ -29348,12 +29348,12 @@ pub static WORD_SUCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SUCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCE_CHILDREN),
+static WORD_SUCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eded"),
@@ -29447,12 +29447,12 @@ pub static WORD_SUCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SUCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUCC_CHILDREN),
+static WORD_SUCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUCC_CHILDREN),
     value: None,
 };
 
-static WORD_SUCC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUCC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_SUCCC_NODE),
@@ -29481,23 +29481,23 @@ static WORD_SUCC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUCCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCU_CHILDREN),
+static WORD_SUCCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ssfully")],
     values: &[&["successfully"]],
     range: 7..=7,
 };
 
-static WORD_SUCCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCS_CHILDREN),
+static WORD_SUCCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eeded"),
         dictgen::InsensitiveStr::Ascii("esfull"),
@@ -29519,12 +29519,12 @@ pub static WORD_SUCCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SUCCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCI_CHILDREN),
+static WORD_SUCCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cently"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -29540,12 +29540,12 @@ pub static WORD_SUCCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SUCCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCE_CHILDREN),
+static WORD_SUCCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cful"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -29669,12 +29669,12 @@ pub static WORD_SUCCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SUCCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCC_CHILDREN),
+static WORD_SUCCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eed"),
         dictgen::InsensitiveStr::Ascii("eeded"),
@@ -29704,12 +29704,12 @@ pub static WORD_SUCCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUB_CHILDREN),
+static WORD_SUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUB_CHILDREN),
     value: None,
 };
 
-static WORD_SUB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SUBA_NODE),
     Some(&WORD_SUBB_NODE),
     Some(&WORD_SUBC_NODE),
@@ -29738,12 +29738,12 @@ static WORD_SUB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUBY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBY_CHILDREN),
+static WORD_SUBY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stem"),
         dictgen::InsensitiveStr::Ascii("stems"),
@@ -29752,23 +29752,23 @@ pub static WORD_SUBY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_SUBU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBU_CHILDREN),
+static WORD_SUBU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rburban")],
     values: &[&["suburban"]],
     range: 7..=7,
 };
 
-static WORD_SUBT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBT_CHILDREN),
+static WORD_SUBT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abels"),
         dictgen::InsensitiveStr::Ascii("ak"),
@@ -29866,12 +29866,12 @@ pub static WORD_SUBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SUBS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUBS_CHILDREN),
+static WORD_SUBS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUBS_CHILDREN),
     value: None,
 };
 
-static WORD_SUBS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUBS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SUBSA_NODE),
     None,
     Some(&WORD_SUBSC_NODE),
@@ -29900,12 +29900,12 @@ static WORD_SUBS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUBSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSY_CHILDREN),
+static WORD_SUBSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sthem"),
         dictgen::InsensitiveStr::Ascii("sthems"),
@@ -29929,23 +29929,23 @@ pub static WORD_SUBSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SUBSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSU_CHILDREN),
+static WORD_SUBSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dized")],
     values: &[&["subsidized"]],
     range: 5..=5,
 };
 
-static WORD_SUBST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUBST_CHILDREN),
+static WORD_SUBST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUBST_CHILDREN),
     value: None,
 };
 
-static WORD_SUBST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUBST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SUBSTA_NODE),
     None,
     None,
@@ -29974,12 +29974,12 @@ static WORD_SUBST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUBSTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTU_CHILDREN),
+static WORD_SUBSTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cture"),
         dictgen::InsensitiveStr::Ascii("ctures"),
@@ -29993,12 +29993,12 @@ pub static WORD_SUBSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_SUBSTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTR_CHILDREN),
+static WORD_SUBSTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -30020,12 +30020,12 @@ pub static WORD_SUBSTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_SUBSTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTI_CHILDREN),
+static WORD_SUBSTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bute"),
         dictgen::InsensitiveStr::Ascii("stutions"),
@@ -30109,12 +30109,12 @@ pub static WORD_SUBSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_SUBSTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTE_CHILDREN),
+static WORD_SUBSTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nces"),
         dictgen::InsensitiveStr::Ascii("ntial"),
@@ -30124,12 +30124,12 @@ pub static WORD_SUBSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_SUBSTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTA_CHILDREN),
+static WORD_SUBSTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -30195,12 +30195,12 @@ pub static WORD_SUBSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_SUBSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSR_CHILDREN),
+static WORD_SUBSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cibe"),
         dictgen::InsensitiveStr::Ascii("cibed"),
@@ -30222,12 +30222,12 @@ pub static WORD_SUBSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SUBSQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSQ_CHILDREN),
+static WORD_SUBSQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uent"),
         dictgen::InsensitiveStr::Ascii("uently"),
@@ -30236,12 +30236,12 @@ pub static WORD_SUBSQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_SUBSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSI_CHILDREN),
+static WORD_SUBSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dary"),
         dictgen::InsensitiveStr::Ascii("dezed"),
@@ -30317,12 +30317,12 @@ pub static WORD_SUBSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUBSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSH_CHILDREN),
+static WORD_SUBSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ystem"),
         dictgen::InsensitiveStr::Ascii("ystems"),
@@ -30331,12 +30331,12 @@ pub static WORD_SUBSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_SUBSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSE_CHILDREN),
+static WORD_SUBSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crion"),
         dictgen::InsensitiveStr::Ascii("dent"),
@@ -30378,12 +30378,12 @@ pub static WORD_SUBSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_SUBSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSC_CHILDREN),
+static WORD_SUBSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eptible"),
         dictgen::InsensitiveStr::Ascii("ibe"),
@@ -30483,23 +30483,23 @@ pub static WORD_SUBSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SUBSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSA_CHILDREN),
+static WORD_SUBSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dized")],
     values: &[&["subsidized"]],
     range: 5..=5,
 };
 
-static WORD_SUBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBR_CHILDREN),
+static WORD_SUBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -30533,23 +30533,23 @@ pub static WORD_SUBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_SUBQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBQ_CHILDREN),
+static WORD_SUBQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uue")],
     values: &[&["subqueue"]],
     range: 3..=3,
 };
 
-static WORD_SUBP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBP_CHILDREN),
+static WORD_SUBP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ackge"),
         dictgen::InsensitiveStr::Ascii("ackges"),
@@ -30571,12 +30571,12 @@ pub static WORD_SUBP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SUBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBO_CHILDREN),
+static WORD_SUBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bjecs"),
         dictgen::InsensitiveStr::Ascii("lders"),
@@ -30594,12 +30594,12 @@ pub static WORD_SUBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_SUBN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBN_CHILDREN),
+static WORD_SUBN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egatiotiation"),
         dictgen::InsensitiveStr::Ascii("egatiotiations"),
@@ -30699,12 +30699,12 @@ pub static WORD_SUBN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=18,
 };
 
-static WORD_SUBM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBM_CHILDREN),
+static WORD_SUBM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achne"),
         dictgen::InsensitiveStr::Ascii("arie"),
@@ -30762,12 +30762,12 @@ pub static WORD_SUBM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SUBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBL_CHILDREN),
+static WORD_SUBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ass"),
         dictgen::InsensitiveStr::Ascii("asse"),
@@ -30793,12 +30793,12 @@ pub static WORD_SUBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SUBJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBJ_CHILDREN),
+static WORD_SUBJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ec"),
         dictgen::InsensitiveStr::Ascii("ectief"),
@@ -30832,12 +30832,12 @@ pub static WORD_SUBJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SUBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBI_CHILDREN),
+static WORD_SUBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rectory"),
         dictgen::InsensitiveStr::Ascii("sdized"),
@@ -30853,23 +30853,23 @@ pub static WORD_SUBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SUBG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBG_CHILDREN),
+static WORD_SUBG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("region")],
     values: &[&["subregion"]],
     range: 6..=6,
 };
 
-static WORD_SUBF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBF_CHILDREN),
+static WORD_SUBF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eatutures"),
         dictgen::InsensitiveStr::Ascii("olfer"),
@@ -30891,12 +30891,12 @@ pub static WORD_SUBF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_SUBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBE_CHILDREN),
+static WORD_SUBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lemet"),
         dictgen::InsensitiveStr::Ascii("lemets"),
@@ -30936,12 +30936,12 @@ pub static WORD_SUBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_SUBD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBD_CHILDREN),
+static WORD_SUBD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irectiories"),
         dictgen::InsensitiveStr::Ascii("irectoires"),
@@ -30969,12 +30969,12 @@ pub static WORD_SUBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_SUBC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBC_CHILDREN),
+static WORD_SUBC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atagories"),
         dictgen::InsensitiveStr::Ascii("atagory"),
@@ -31038,12 +31038,12 @@ pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_SUBB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBB_CHILDREN),
+static WORD_SUBB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mitted"),
         dictgen::InsensitiveStr::Ascii("tle"),
@@ -31052,12 +31052,12 @@ pub static WORD_SUBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SUBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBA_CHILDREN),
+static WORD_SUBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rmine"),
         dictgen::InsensitiveStr::Ascii("rmines"),
@@ -31066,12 +31066,12 @@ pub static WORD_SUBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_SUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUA_CHILDREN),
+static WORD_SUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sage"),
         dictgen::InsensitiveStr::Ascii("sages"),
@@ -31080,12 +31080,12 @@ pub static WORD_SUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_ST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ST_CHILDREN),
+static WORD_ST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ST_CHILDREN),
     value: None,
 };
 
-static WORD_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STA_NODE),
     None,
     Some(&WORD_STC_NODE),
@@ -31114,12 +31114,12 @@ static WORD_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STY_CHILDREN),
+static WORD_STY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STY_CHILDREN),
     value: None,
 };
 
-pub static WORD_STY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("ilistic"),
@@ -31147,12 +31147,12 @@ pub static WORD_STY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_STU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STU_CHILDREN),
+static WORD_STU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STU_CHILDREN),
     value: None,
 };
 
-static WORD_STU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STUA_NODE),
     Some(&WORD_STUB_NODE),
     Some(&WORD_STUC_NODE),
@@ -31181,12 +31181,12 @@ static WORD_STU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUT_CHILDREN),
+static WORD_STUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("down"),
         dictgen::InsensitiveStr::Ascii("terring"),
@@ -31196,12 +31196,12 @@ pub static WORD_STUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_STUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUR_CHILDREN),
+static WORD_STUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctural"),
@@ -31231,12 +31231,12 @@ pub static WORD_STUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_STUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUP_CHILDREN),
+static WORD_STUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dily"),
         dictgen::InsensitiveStr::Ascii("idfree"),
@@ -31260,23 +31260,23 @@ pub static WORD_STUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_STUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUN_CHILDREN),
+static WORD_STUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ami")],
     values: &[&["tsunami"]],
     range: 3..=3,
 };
 
-static WORD_STUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUM_CHILDREN),
+static WORD_STUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("beld"),
         dictgen::InsensitiveStr::Ascii("mac"),
@@ -31285,12 +31285,12 @@ pub static WORD_STUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_STUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUI_CHILDREN),
+static WORD_STUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("do"),
         dictgen::InsensitiveStr::Ascii("dos"),
@@ -31301,12 +31301,12 @@ pub static WORD_STUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_STUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUG_CHILDREN),
+static WORD_STUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gle"),
         dictgen::InsensitiveStr::Ascii("gles"),
@@ -31316,34 +31316,34 @@ pub static WORD_STUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_STUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUF_CHILDREN),
+static WORD_STUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUF_CHILDREN),
     value: Some(&["stuff"]),
 };
 
-pub static WORD_STUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_STUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUE_CHILDREN),
+static WORD_STUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nts")],
     values: &[&["students"]],
     range: 3..=3,
 };
 
-static WORD_STUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUD_CHILDREN),
+static WORD_STUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dy"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -31379,12 +31379,12 @@ pub static WORD_STUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_STUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUC_CHILDREN),
+static WORD_STUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ked"),
         dictgen::InsensitiveStr::Ascii("kt"),
@@ -31406,12 +31406,12 @@ pub static WORD_STUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_STUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUB_CHILDREN),
+static WORD_STUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bon"),
         dictgen::InsensitiveStr::Ascii("borness"),
@@ -31431,12 +31431,12 @@ pub static WORD_STUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_STUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUA_CHILDREN),
+static WORD_STUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -31450,12 +31450,12 @@ pub static WORD_STUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_STT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STT_CHILDREN),
+static WORD_STT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STT_CHILDREN),
     value: None,
 };
 
-pub static WORD_STT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eting"),
@@ -31479,12 +31479,12 @@ pub static WORD_STT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_STS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STS_CHILDREN),
+static WORD_STS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STS_CHILDREN),
     value: None,
 };
 
-pub static WORD_STS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tionary"),
@@ -31504,12 +31504,12 @@ pub static WORD_STS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_STR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STR_CHILDREN),
+static WORD_STR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STR_CHILDREN),
     value: None,
 };
 
-static WORD_STR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STRA_NODE),
     None,
     Some(&WORD_STRC_NODE),
@@ -31538,34 +31538,34 @@ static WORD_STR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRY_CHILDREN),
+static WORD_STRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ofoam")],
     values: &[&["styrofoam"]],
     range: 5..=5,
 };
 
-static WORD_STRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRW_CHILDREN),
+static WORD_STRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aberry")],
     values: &[&["strawberry"]],
     range: 6..=6,
 };
 
-static WORD_STRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRU_CHILDREN),
+static WORD_STRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cgture"),
@@ -31691,34 +31691,34 @@ pub static WORD_STRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_STRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRT_CHILDREN),
+static WORD_STRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["string"]],
     range: 3..=3,
 };
 
-static WORD_STRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRP_CHILDREN),
+static WORD_STRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iped")],
     values: &[&["stripped"]],
     range: 4..=4,
 };
 
-static WORD_STRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRO_CHILDREN),
+static WORD_STRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -31766,12 +31766,12 @@ pub static WORD_STRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_STRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRN_CHILDREN),
+static WORD_STRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -31780,23 +31780,23 @@ pub static WORD_STRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_STRK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRK_CHILDREN),
+static WORD_STRK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRK_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ethrough")],
     values: &[&["strikethrough"]],
     range: 8..=8,
 };
 
-static WORD_STRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRI_CHILDREN),
+static WORD_STRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aght"),
         dictgen::InsensitiveStr::Ascii("aghten"),
@@ -31878,12 +31878,12 @@ pub static WORD_STRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_STRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STRE_CHILDREN),
+static WORD_STRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STRE_CHILDREN),
     value: None,
 };
 
-static WORD_STRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STREA_NODE),
     None,
     Some(&WORD_STREC_NODE),
@@ -31912,12 +31912,12 @@ static WORD_STRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRET_CHILDREN),
+static WORD_STRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRET_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chs"),
         dictgen::InsensitiveStr::Ascii("egically"),
@@ -31926,12 +31926,12 @@ pub static WORD_STRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_STRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRES_CHILDREN),
+static WORD_STRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sade"),
         dictgen::InsensitiveStr::Ascii("sende"),
@@ -31949,34 +31949,34 @@ pub static WORD_STRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_STRER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRER_CHILDREN),
+static WORD_STRER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRER_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rror")],
     values: &[&["strerror"]],
     range: 4..=4,
 };
 
-static WORD_STREO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREO_CHILDREN),
+static WORD_STREO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREO_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("id")],
     values: &[&["steroid"]],
     range: 2..=2,
 };
 
-static WORD_STREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREN_CHILDREN),
+static WORD_STREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gh"),
         dictgen::InsensitiveStr::Ascii("ghen"),
@@ -32030,12 +32030,12 @@ pub static WORD_STREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_STREM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREM_CHILDREN),
+static WORD_STREM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREM_CHILDREN),
     value: Some(&["stream"]),
 };
 
-pub static WORD_STREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ear"),
@@ -32044,12 +32044,12 @@ pub static WORD_STREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_STREI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREI_CHILDREN),
+static WORD_STREI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chung"),
         dictgen::InsensitiveStr::Ascii("ght"),
@@ -32081,12 +32081,12 @@ pub static WORD_STREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_STREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREG_CHILDREN),
+static WORD_STREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nth"),
         dictgen::InsensitiveStr::Ascii("nthen"),
@@ -32104,12 +32104,12 @@ pub static WORD_STREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_STREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREE_CHILDREN),
+static WORD_STREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mlining"),
@@ -32118,12 +32118,12 @@ pub static WORD_STREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_STREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREC_CHILDREN),
+static WORD_STREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hed"),
@@ -32155,12 +32155,12 @@ pub static WORD_STREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_STREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREA_CHILDREN),
+static WORD_STREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ching"),
         dictgen::InsensitiveStr::Ascii("made"),
@@ -32202,12 +32202,12 @@ pub static WORD_STREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_STRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRC_CHILDREN),
+static WORD_STRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iter"),
         dictgen::InsensitiveStr::Ascii("ture"),
@@ -32229,12 +32229,12 @@ pub static WORD_STRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_STRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STRA_CHILDREN),
+static WORD_STRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STRA_CHILDREN),
     value: None,
 };
 
-static WORD_STRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_STRAC_NODE),
@@ -32263,12 +32263,12 @@ static WORD_STRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STRAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAW_CHILDREN),
+static WORD_STRAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("barry"),
         dictgen::InsensitiveStr::Ascii("beary"),
@@ -32298,23 +32298,23 @@ pub static WORD_STRAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_STRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAV_CHILDREN),
+static WORD_STRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["starvation"]],
     range: 5..=5,
 };
 
-static WORD_STRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAT_CHILDREN),
+static WORD_STRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAT_CHILDREN),
     value: Some(&["start", "strata"]),
 };
 
-pub static WORD_STRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agically"),
         dictgen::InsensitiveStr::Ascii("agies"),
@@ -32362,12 +32362,12 @@ pub static WORD_STRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_STRAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAR_CHILDREN),
+static WORD_STRAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -32378,12 +32378,12 @@ pub static WORD_STRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_STRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAN_CHILDREN),
+static WORD_STRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAN_CHILDREN),
     value: Some(&["strand", "strain"]),
 };
 
-pub static WORD_STRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gel"),
@@ -32409,12 +32409,12 @@ pub static WORD_STRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_STRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAM_CHILDREN),
+static WORD_STRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAM_CHILDREN),
     value: Some(&["steam", "stream", "tram"]),
 };
 
-pub static WORD_STRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -32423,12 +32423,12 @@ pub static WORD_STRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_STRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAI_CHILDREN),
+static WORD_STRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gh"),
         dictgen::InsensitiveStr::Ascii("ghforward"),
@@ -32492,12 +32492,12 @@ pub static WORD_STRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_STRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAG_CHILDREN),
+static WORD_STRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("edy"),
@@ -32523,12 +32523,12 @@ pub static WORD_STRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_STRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAD_CHILDREN),
+static WORD_STRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egies"),
         dictgen::InsensitiveStr::Ascii("egy"),
@@ -32537,23 +32537,23 @@ pub static WORD_STRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_STRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAC_CHILDREN),
+static WORD_STRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["stack", "track"]],
     range: 1..=1,
 };
 
-static WORD_STP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STP_CHILDREN),
+static WORD_STP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STP_CHILDREN),
     value: None,
 };
 
-pub static WORD_STP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iped"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -32562,12 +32562,12 @@ pub static WORD_STP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_STO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STO_CHILDREN),
+static WORD_STO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STO_CHILDREN),
     value: None,
 };
 
-pub static WORD_STO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -32675,12 +32675,12 @@ pub static WORD_STO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_STN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STN_CHILDREN),
+static WORD_STN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("dard"),
@@ -32689,12 +32689,12 @@ pub static WORD_STN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_STL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STL_CHILDREN),
+static WORD_STL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STL_CHILDREN),
     value: None,
 };
 
-pub static WORD_STL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aker"),
         dictgen::InsensitiveStr::Ascii("akers"),
@@ -32716,12 +32716,12 @@ pub static WORD_STL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_STI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STI_CHILDREN),
+static WORD_STI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ches"),
         dictgen::InsensitiveStr::Ascii("chted"),
@@ -32819,23 +32819,23 @@ pub static WORD_STI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_STH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STH_CHILDREN),
+static WORD_STH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STH_CHILDREN),
     value: None,
 };
 
-pub static WORD_STH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["the"]],
     range: 1..=1,
 };
 
-static WORD_STE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STE_CHILDREN),
+static WORD_STE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STE_CHILDREN),
     value: None,
 };
 
-pub static WORD_STE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adilly"),
         dictgen::InsensitiveStr::Ascii("adliy"),
@@ -32961,12 +32961,12 @@ pub static WORD_STE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_STD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STD_CHILDREN),
+static WORD_STD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STD_CHILDREN),
     value: None,
 };
 
-pub static WORD_STD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anard"),
         dictgen::InsensitiveStr::Ascii("anards"),
@@ -32986,23 +32986,23 @@ pub static WORD_STD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_STC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STC_CHILDREN),
+static WORD_STC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("okbrush")],
     values: &[&["stockbrush"]],
     range: 7..=7,
 };
 
-static WORD_STA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STA_CHILDREN),
+static WORD_STA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STA_CHILDREN),
     value: None,
 };
 
-static WORD_STA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STAA_NODE),
     Some(&WORD_STAB_NODE),
     Some(&WORD_STAC_NODE),
@@ -33031,12 +33031,12 @@ static WORD_STA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAW_CHILDREN),
+static WORD_STAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("berries"),
         dictgen::InsensitiveStr::Ascii("berry"),
@@ -33046,12 +33046,12 @@ pub static WORD_STAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_STAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAU_CHILDREN),
+static WORD_STAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lk"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -33073,12 +33073,12 @@ pub static WORD_STAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_STAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STAT_CHILDREN),
+static WORD_STAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STAT_CHILDREN),
     value: None,
 };
 
-static WORD_STAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STATA_NODE),
     None,
     None,
@@ -33107,12 +33107,12 @@ static WORD_STAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATU_CHILDREN),
+static WORD_STATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATU_CHILDREN),
     value: Some(&["status"]),
 };
 
-pub static WORD_STATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bar"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -33148,12 +33148,12 @@ pub static WORD_STATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_STATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATT_CHILDREN),
+static WORD_STATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ered"),
         dictgen::InsensitiveStr::Ascii("istic"),
@@ -33164,12 +33164,12 @@ pub static WORD_STATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_STATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATS_CHILDREN),
+static WORD_STATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("itical"),
@@ -33178,12 +33178,12 @@ pub static WORD_STATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_STATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATR_CHILDREN),
+static WORD_STATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -33192,12 +33192,12 @@ pub static WORD_STATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_STATM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATM_CHILDREN),
+static WORD_STATM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATM_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enet"),
         dictgen::InsensitiveStr::Ascii("enmt"),
@@ -33213,23 +33213,23 @@ pub static WORD_STATM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_STATL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATL_CHILDREN),
+static WORD_STATL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATL_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["stateless"]],
     range: 3..=3,
 };
 
-static WORD_STATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATI_CHILDREN),
+static WORD_STATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATI_CHILDREN),
     value: Some(&["statuses", "state", "static"]),
 };
 
-pub static WORD_STATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caly"),
         dictgen::InsensitiveStr::Ascii("cists"),
@@ -33309,12 +33309,12 @@ pub static WORD_STATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_STATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATE_CHILDREN),
+static WORD_STATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("full"),
         dictgen::InsensitiveStr::Ascii("gies"),
@@ -33362,12 +33362,12 @@ pub static WORD_STATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_STATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATA_CHILDREN),
+static WORD_STATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("menet"),
         dictgen::InsensitiveStr::Ascii("menets"),
@@ -33376,12 +33376,12 @@ pub static WORD_STATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_STAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAR_CHILDREN),
+static WORD_STAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -33475,34 +33475,34 @@ pub static WORD_STAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_STAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAP_CHILDREN),
+static WORD_STAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAP_CHILDREN),
     value: Some(&["step", "stop"]),
 };
 
-pub static WORD_STAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["steps", "stops"]],
     range: 1..=1,
 };
 
-static WORD_STAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAO_CHILDREN),
+static WORD_STAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("shi")],
     values: &[&["satoshi"]],
     range: 3..=3,
 };
 
-static WORD_STAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAN_CHILDREN),
+static WORD_STAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alone"),
         dictgen::InsensitiveStr::Ascii("ard"),
@@ -33608,12 +33608,12 @@ pub static WORD_STAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_STAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAM_CHILDREN),
+static WORD_STAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("entent"),
@@ -33633,12 +33633,12 @@ pub static WORD_STAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_STAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAL_CHILDREN),
+static WORD_STAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agtite"),
         dictgen::InsensitiveStr::Ascii("ekrs"),
@@ -33649,12 +33649,12 @@ pub static WORD_STAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_STAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAK_CHILDREN),
+static WORD_STAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eboard"),
         dictgen::InsensitiveStr::Ascii("eboarding"),
@@ -33670,12 +33670,12 @@ pub static WORD_STAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_STAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAI_CHILDREN),
+static WORD_STAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cally"),
         dictgen::InsensitiveStr::Ascii("dum"),
@@ -33703,12 +33703,12 @@ pub static WORD_STAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_STAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAG_CHILDREN),
+static WORD_STAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("garing"),
         dictgen::InsensitiveStr::Ascii("gerring"),
@@ -33724,34 +33724,34 @@ pub static WORD_STAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_STAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAF_CHILDREN),
+static WORD_STAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAF_CHILDREN),
     value: Some(&["staff"]),
 };
 
-pub static WORD_STAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_STAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAE_CHILDREN),
+static WORD_STAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAE_CHILDREN),
     value: Some(&["state"]),
 };
 
-pub static WORD_STAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ment")],
     values: &[&["statement"]],
     range: 4..=4,
 };
 
-static WORD_STAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAD_CHILDREN),
+static WORD_STAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ius"),
@@ -33785,12 +33785,12 @@ pub static WORD_STAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_STAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAC_CHILDREN),
+static WORD_STAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("ionary"),
@@ -33800,12 +33800,12 @@ pub static WORD_STAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_STAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAB_CHILDREN),
+static WORD_STAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alization"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -33861,23 +33861,23 @@ pub static WORD_STAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_STAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAA_CHILDREN),
+static WORD_STAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tus")],
     values: &[&["status"]],
     range: 3..=3,
 };
 
-static WORD_SS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SS_CHILDREN),
+static WORD_SS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ame"),
         dictgen::InsensitiveStr::Ascii("ee"),
@@ -33899,12 +33899,12 @@ pub static WORD_SS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SR_CHILDREN),
+static WORD_SR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arted"),
         dictgen::InsensitiveStr::Ascii("bg"),
@@ -33996,12 +33996,12 @@ pub static WORD_SR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_SQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SQ_CHILDREN),
+static WORD_SQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("ared"),
@@ -34107,12 +34107,12 @@ pub static WORD_SQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SP_CHILDREN),
+static WORD_SP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SP_CHILDREN),
     value: None,
 };
 
-static WORD_SP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPA_NODE),
     None,
     Some(&WORD_SPC_NODE),
@@ -34141,12 +34141,12 @@ static WORD_SP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPW_CHILDREN),
+static WORD_SPW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("aned"),
@@ -34157,12 +34157,12 @@ pub static WORD_SPW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPU_CHILDREN),
+static WORD_SPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rios"),
         dictgen::InsensitiveStr::Ascii("rrious"),
@@ -34171,23 +34171,23 @@ pub static WORD_SPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_SPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPT_CHILDREN),
+static WORD_SPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("intf")],
     values: &[&["sprintf"]],
     range: 4..=4,
 };
 
-static WORD_SPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPS_CHILDREN),
+static WORD_SPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -34198,12 +34198,12 @@ pub static WORD_SPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_SPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPR_CHILDREN),
+static WORD_SPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("akling"),
         dictgen::InsensitiveStr::Ascii("ayade"),
@@ -34307,12 +34307,12 @@ pub static WORD_SPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_SPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPP_CHILDREN),
+static WORD_SPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eches"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -34332,12 +34332,12 @@ pub static WORD_SPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPO_CHILDREN),
+static WORD_SPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -34467,12 +34467,12 @@ pub static WORD_SPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_SPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPL_CHILDREN),
+static WORD_SPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aton"),
         dictgen::InsensitiveStr::Ascii("atooon"),
@@ -34514,12 +34514,12 @@ pub static WORD_SPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPI_CHILDREN),
+static WORD_SPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cific"),
         dictgen::InsensitiveStr::Ascii("cified"),
@@ -34583,12 +34583,12 @@ pub static WORD_SPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_SPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPH_CHILDREN),
+static WORD_SPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agetti"),
         dictgen::InsensitiveStr::Ascii("ereos"),
@@ -34597,12 +34597,12 @@ pub static WORD_SPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_SPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPE_CHILDREN),
+static WORD_SPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPE_CHILDREN),
     value: None,
 };
 
-static WORD_SPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEA_NODE),
     None,
     Some(&WORD_SPEC_NODE),
@@ -34631,12 +34631,12 @@ static WORD_SPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEZ_NODE),
 ];
 
-static WORD_SPEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEZ_CHILDREN),
+static WORD_SPEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialiced"),
         dictgen::InsensitiveStr::Ascii("ialisation"),
@@ -34654,12 +34654,12 @@ pub static WORD_SPEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPET_CHILDREN),
+static WORD_SPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ember"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -34675,12 +34675,12 @@ pub static WORD_SPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPES_CHILDREN),
+static WORD_SPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hal"),
         dictgen::InsensitiveStr::Ascii("hally"),
@@ -34718,12 +34718,12 @@ pub static WORD_SPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPER_CHILDREN),
+static WORD_SPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ately"),
@@ -34739,12 +34739,12 @@ pub static WORD_SPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SPEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEP_CHILDREN),
+static WORD_SPEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("arated"),
@@ -34780,23 +34780,23 @@ pub static WORD_SPEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEN_CHILDREN),
+static WORD_SPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dour")],
     values: &[&["splendour"]],
     range: 4..=4,
 };
 
-static WORD_SPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEL_CHILDREN),
+static WORD_SPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("lig"),
@@ -34812,23 +34812,23 @@ pub static WORD_SPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SPEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEK_CHILDREN),
+static WORD_SPEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aing")],
     values: &[&["speaking"]],
     range: 4..=4,
 };
 
-static WORD_SPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEI_CHILDREN),
+static WORD_SPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("calist"),
@@ -34860,12 +34860,12 @@ pub static WORD_SPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SPEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEH_CHILDREN),
+static WORD_SPEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erical"),
         dictgen::InsensitiveStr::Ascii("res"),
@@ -34875,12 +34875,12 @@ pub static WORD_SPEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SPEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEF_CHILDREN),
+static WORD_SPEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEF_CHILDREN),
     value: None,
 };
 
-static WORD_SPEF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEFA_NODE),
     None,
     Some(&WORD_SPEFC_NODE),
@@ -34909,23 +34909,23 @@ static WORD_SPEF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPEFY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFY_CHILDREN),
+static WORD_SPEFY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPEFY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["specifying"]],
     range: 3..=3,
 };
 
-static WORD_SPEFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEFI_CHILDREN),
+static WORD_SPEFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEFI_CHILDREN),
     value: None,
 };
 
-static WORD_SPEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEFI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEFIA_NODE),
     None,
     Some(&WORD_SPEFIC_NODE),
@@ -34954,23 +34954,23 @@ static WORD_SPEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPEFIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIY_CHILDREN),
+static WORD_SPEFIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPEFIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["specifying"]],
     range: 3..=3,
 };
 
-static WORD_SPEFIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIX_CHILDREN),
+static WORD_SPEFIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35024,12 +35024,12 @@ pub static WORD_SPEFIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_SPEFII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFII_CHILDREN),
+static WORD_SPEFII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFII_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -35103,12 +35103,12 @@ pub static WORD_SPEFII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_SPEFIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIF_CHILDREN),
+static WORD_SPEFIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35170,12 +35170,12 @@ pub static WORD_SPEFIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_SPEFIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIE_CHILDREN),
+static WORD_SPEFIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -35191,12 +35191,12 @@ pub static WORD_SPEFIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_SPEFIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEFIC_CHILDREN),
+static WORD_SPEFIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEFIC_CHILDREN),
     value: Some(&["specific"]),
 };
 
-static WORD_SPEFIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEFIC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEFICA_NODE),
     None,
     None,
@@ -35225,34 +35225,34 @@ static WORD_SPEFIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPEFICY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICY_CHILDREN),
+static WORD_SPEFICY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPEFICY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["specifying"]],
     range: 3..=3,
 };
 
-static WORD_SPEFICS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICS_CHILDREN),
+static WORD_SPEFICS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICS_CHILDREN),
     value: Some(&["specifics"]),
 };
 
-pub static WORD_SPEFICS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SPEFICI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEFICI_CHILDREN),
+static WORD_SPEFICI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEFICI_CHILDREN),
     value: None,
 };
 
-static WORD_SPEFICI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEFICI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEFICIA_NODE),
     None,
     Some(&WORD_SPEFICIC_NODE),
@@ -35281,23 +35281,23 @@ static WORD_SPEFICI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPEFICIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIY_CHILDREN),
+static WORD_SPEFICIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPEFICIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["specifying"]],
     range: 3..=3,
 };
 
-static WORD_SPEFICIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIT_CHILDREN),
+static WORD_SPEFICIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35349,12 +35349,12 @@ pub static WORD_SPEFICIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_SPEFICIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIL_CHILDREN),
+static WORD_SPEFICIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lally"),
         dictgen::InsensitiveStr::Ascii("lation"),
@@ -35406,12 +35406,12 @@ pub static WORD_SPEFICIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=9,
 };
 
-static WORD_SPEFICII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICII_CHILDREN),
+static WORD_SPEFICII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICII_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -35447,12 +35447,12 @@ pub static WORD_SPEFICII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=7,
 };
 
-static WORD_SPEFICIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIF_CHILDREN),
+static WORD_SPEFICIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35524,12 +35524,12 @@ pub static WORD_SPEFICIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_SPEFICIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIE_CHILDREN),
+static WORD_SPEFICIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -35553,12 +35553,12 @@ pub static WORD_SPEFICIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=3,
 };
 
-static WORD_SPEFICIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIC_CHILDREN),
+static WORD_SPEFICIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIC_CHILDREN),
     value: Some(&["specific"]),
 };
 
-pub static WORD_SPEFICIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35574,12 +35574,12 @@ pub static WORD_SPEFICIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=6,
 };
 
-static WORD_SPEFICIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIA_CHILDREN),
+static WORD_SPEFICIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("llally"),
@@ -35637,12 +35637,12 @@ pub static WORD_SPEFICIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 3..=10,
 };
 
-static WORD_SPEFICE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICE_CHILDREN),
+static WORD_SPEFICE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -35666,12 +35666,12 @@ pub static WORD_SPEFICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_SPEFICA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICA_CHILDREN),
+static WORD_SPEFICA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -35687,12 +35687,12 @@ pub static WORD_SPEFICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=5,
 };
 
-static WORD_SPEFIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIA_CHILDREN),
+static WORD_SPEFIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -35701,12 +35701,12 @@ pub static WORD_SPEFIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_SPEFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFE_CHILDREN),
+static WORD_SPEFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("id"),
         dictgen::InsensitiveStr::Ascii("ir"),
@@ -35722,12 +35722,12 @@ pub static WORD_SPEFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SPEFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFC_CHILDREN),
+static WORD_SPEFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifiable"),
         dictgen::InsensitiveStr::Ascii("ific"),
@@ -35759,12 +35759,12 @@ pub static WORD_SPEFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_SPEFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFA_CHILDREN),
+static WORD_SPEFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lly"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -35778,12 +35778,12 @@ pub static WORD_SPEFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SPEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEE_CHILDREN),
+static WORD_SPEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("aking"),
@@ -35815,12 +35815,12 @@ pub static WORD_SPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPED_CHILDREN),
+static WORD_SPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ific"),
         dictgen::InsensitiveStr::Ascii("ified"),
@@ -35830,12 +35830,12 @@ pub static WORD_SPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEC_CHILDREN),
+static WORD_SPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEC_CHILDREN),
     value: None,
 };
 
-static WORD_SPEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPECA_NODE),
     None,
     None,
@@ -35864,23 +35864,23 @@ static WORD_SPEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPECY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECY_CHILDREN),
+static WORD_SPECY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fing")],
     values: &[&["specifying"]],
     range: 4..=4,
 };
 
-static WORD_SPECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECU_CHILDREN),
+static WORD_SPECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alte"),
         dictgen::InsensitiveStr::Ascii("alting"),
@@ -35910,12 +35910,12 @@ pub static WORD_SPECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SPECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECT_CHILDREN),
+static WORD_SPECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acuarly"),
         dictgen::InsensitiveStr::Ascii("aculair"),
@@ -35987,34 +35987,34 @@ pub static WORD_SPECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SPECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECR_CHILDREN),
+static WORD_SPECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tal")],
     values: &[&["spectral"]],
     range: 3..=3,
 };
 
-static WORD_SPECK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECK_CHILDREN),
+static WORD_SPECK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tor")],
     values: &[&["specter"]],
     range: 3..=3,
 };
 
-static WORD_SPECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPECI_CHILDREN),
+static WORD_SPECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPECI_CHILDREN),
     value: None,
 };
 
-static WORD_SPECI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPECI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPECIA_NODE),
     None,
     Some(&WORD_SPECIC_NODE),
@@ -36043,12 +36043,12 @@ static WORD_SPECI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPECIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIY_CHILDREN),
+static WORD_SPECIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPECIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fing"),
         dictgen::InsensitiveStr::Ascii("fying"),
@@ -36058,34 +36058,34 @@ pub static WORD_SPECIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_SPECIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIV_CHILDREN),
+static WORD_SPECIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ied")],
     values: &[&["specified"]],
     range: 3..=3,
 };
 
-static WORD_SPECIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIS_CHILDREN),
+static WORD_SPECIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["specials"]],
     range: 1..=1,
 };
 
-static WORD_SPECIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIR_CHILDREN),
+static WORD_SPECIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -36094,12 +36094,12 @@ pub static WORD_SPECIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_SPECIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIM_CHILDREN),
+static WORD_SPECIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("ine"),
@@ -36109,12 +36109,12 @@ pub static WORD_SPECIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_SPECIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIL_CHILDREN),
+static WORD_SPECIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aized"),
         dictgen::InsensitiveStr::Ascii("azations"),
@@ -36142,12 +36142,12 @@ pub static WORD_SPECIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_SPECII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECII_CHILDREN),
+static WORD_SPECII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECII_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -36165,12 +36165,12 @@ pub static WORD_SPECII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_SPECIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPECIF_CHILDREN),
+static WORD_SPECIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPECIF_CHILDREN),
     value: None,
 };
 
-static WORD_SPECIF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPECIF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPECIFA_NODE),
     None,
     Some(&WORD_SPECIFC_NODE),
@@ -36199,12 +36199,12 @@ static WORD_SPECIF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPECIFY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFY_CHILDREN),
+static WORD_SPECIFY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -36220,45 +36220,45 @@ pub static WORD_SPECIFY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_SPECIFV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFV_CHILDREN),
+static WORD_SPECIFV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFV_CHILDREN),
     value: Some(&["specific"]),
 };
 
-pub static WORD_SPECIFV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SPECIFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFU_CHILDREN),
+static WORD_SPECIFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFU_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPECIFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SPECIFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFT_CHILDREN),
+static WORD_SPECIFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFT_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPECIFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SPECIFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFR_CHILDREN),
+static WORD_SPECIFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -36267,12 +36267,12 @@ pub static WORD_SPECIFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=3,
 };
 
-static WORD_SPECIFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFI_CHILDREN),
+static WORD_SPECIFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFI_CHILDREN),
     value: Some(&["specific", "specify"]),
 };
 
-pub static WORD_SPECIFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -36384,12 +36384,12 @@ pub static WORD_SPECIFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_SPECIFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFF_CHILDREN),
+static WORD_SPECIFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -36398,12 +36398,12 @@ pub static WORD_SPECIFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_SPECIFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFE_CHILDREN),
+static WORD_SPECIFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -36413,12 +36413,12 @@ pub static WORD_SPECIFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=2,
 };
 
-static WORD_SPECIFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFC_CHILDREN),
+static WORD_SPECIFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFC_CHILDREN),
     value: Some(&["specific"]),
 };
 
-pub static WORD_SPECIFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -36436,23 +36436,23 @@ pub static WORD_SPECIFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=6,
 };
 
-static WORD_SPECIFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFA_CHILDREN),
+static WORD_SPECIFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ctions")],
     values: &[&["specifications"]],
     range: 6..=6,
 };
 
-static WORD_SPECIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIE_CHILDREN),
+static WORD_SPECIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -36461,23 +36461,23 @@ pub static WORD_SPECIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_SPECID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECID_CHILDREN),
+static WORD_SPECID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECID_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ic")],
     values: &[&["specific"]],
     range: 2..=2,
 };
 
-static WORD_SPECIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIC_CHILDREN),
+static WORD_SPECIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIC_CHILDREN),
     value: Some(&["specific"]),
 };
 
-pub static WORD_SPECIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -36487,12 +36487,12 @@ pub static WORD_SPECIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_SPECIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIA_CHILDREN),
+static WORD_SPECIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -36586,12 +36586,12 @@ pub static WORD_SPECIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_SPECF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECF_CHILDREN),
+static WORD_SPECF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -36641,12 +36641,12 @@ pub static WORD_SPECF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SPECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECE_CHILDREN),
+static WORD_SPECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECE_CHILDREN),
     value: Some(&["space", "spice"]),
 };
 
-pub static WORD_SPECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fic"),
         dictgen::InsensitiveStr::Ascii("fically"),
@@ -36670,12 +36670,12 @@ pub static WORD_SPECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SPECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECA_CHILDREN),
+static WORD_SPECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("il"),
         dictgen::InsensitiveStr::Ascii("ilist"),
@@ -36715,12 +36715,12 @@ pub static WORD_SPECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_SPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEA_CHILDREN),
+static WORD_SPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -36758,12 +36758,12 @@ pub static WORD_SPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPC_CHILDREN),
+static WORD_SPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -36797,12 +36797,12 @@ pub static WORD_SPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPA_CHILDREN),
+static WORD_SPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cebr"),
         dictgen::InsensitiveStr::Ascii("cegoat"),
@@ -36924,12 +36924,12 @@ pub static WORD_SPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_SO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SO_CHILDREN),
+static WORD_SO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SO_CHILDREN),
     value: None,
 };
 
-static WORD_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SOA_NODE),
     Some(&WORD_SOB_NODE),
     Some(&WORD_SOC_NODE),
@@ -36958,23 +36958,23 @@ static WORD_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOW_CHILDREN),
+static WORD_SOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["sow"]],
     range: 1..=1,
 };
 
-static WORD_SOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOV_CHILDREN),
+static WORD_SOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eits"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -37032,12 +37032,12 @@ pub static WORD_SOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_SOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SOU_CHILDREN),
+static WORD_SOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SOU_CHILDREN),
     value: None,
 };
 
-static WORD_SOU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SOU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SOUB_NODE),
     Some(&WORD_SOUC_NODE),
@@ -37066,12 +37066,12 @@ static WORD_SOU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUV_CHILDREN),
+static WORD_SOUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enier"),
         dictgen::InsensitiveStr::Ascii("eniers"),
@@ -37095,12 +37095,12 @@ pub static WORD_SOUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_SOUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUT_CHILDREN),
+static WORD_SOUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hampon"),
         dictgen::InsensitiveStr::Ascii("hamption"),
@@ -37146,23 +37146,23 @@ pub static WORD_SOUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SOUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUS_CHILDREN),
+static WORD_SOUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("traction")],
     values: &[&["subtraction"]],
     range: 8..=8,
 };
 
-static WORD_SOUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUR_CHILDREN),
+static WORD_SOUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("braten"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -37206,12 +37206,12 @@ pub static WORD_SOUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SOUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUN_CHILDREN),
+static WORD_SOUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dard"),
         dictgen::InsensitiveStr::Ascii("drtack"),
@@ -37237,12 +37237,12 @@ pub static WORD_SOUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SOUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUL_CHILDREN),
+static WORD_SOUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -37252,12 +37252,12 @@ pub static WORD_SOUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SOUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUD_CHILDREN),
+static WORD_SOUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -37267,12 +37267,12 @@ pub static WORD_SOUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SOUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUC_CHILDREN),
+static WORD_SOUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -37290,23 +37290,23 @@ pub static WORD_SOUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_SOUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUB_CHILDREN),
+static WORD_SOUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["double"]],
     range: 2..=2,
 };
 
-static WORD_SOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOT_CHILDREN),
+static WORD_SOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erd"),
         dictgen::InsensitiveStr::Ascii("fware"),
@@ -37338,23 +37338,23 @@ pub static WORD_SOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOS_CHILDREN),
+static WORD_SOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cket")],
     values: &[&["socket"]],
     range: 4..=4,
 };
 
-static WORD_SOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOR_CHILDREN),
+static WORD_SOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cercy"),
@@ -37400,12 +37400,12 @@ pub static WORD_SOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOP_CHILDREN),
+static WORD_SOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arnos"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -37447,12 +37447,12 @@ pub static WORD_SOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOO_CHILDREN),
+static WORD_SOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aside"),
         dictgen::InsensitiveStr::Ascii("donim"),
@@ -37486,12 +37486,12 @@ pub static WORD_SOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_SON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SON_CHILDREN),
+static WORD_SON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SON_CHILDREN),
     value: None,
 };
 
-pub static WORD_SON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ething"),
         dictgen::InsensitiveStr::Ascii("glar"),
@@ -37511,12 +37511,12 @@ pub static WORD_SON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SOM_CHILDREN),
+static WORD_SOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SOM_CHILDREN),
     value: Some(&["some"]),
 };
 
-static WORD_SOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SOM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SOMA_NODE),
     None,
     None,
@@ -37545,12 +37545,12 @@ static WORD_SOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOMW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMW_CHILDREN),
+static WORD_SOMW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hat"),
         dictgen::InsensitiveStr::Ascii("here"),
@@ -37561,12 +37561,12 @@ pub static WORD_SOMW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SOMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMT_CHILDREN),
+static WORD_SOMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hign"),
         dictgen::InsensitiveStr::Ascii("hing"),
@@ -37584,12 +37584,12 @@ pub static WORD_SOMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SOMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMO_CHILDREN),
+static WORD_SOMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enes"),
         dictgen::InsensitiveStr::Ascii("ne"),
@@ -37598,23 +37598,23 @@ pub static WORD_SOMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SOMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMM_CHILDREN),
+static WORD_SOMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["some"]],
     range: 1..=1,
 };
 
-static WORD_SOME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SOME_CHILDREN),
+static WORD_SOME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SOME_CHILDREN),
     value: None,
 };
 
-static WORD_SOME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SOME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SOMEB_NODE),
     None,
@@ -37643,12 +37643,12 @@ static WORD_SOME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOMEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEW_CHILDREN),
+static WORD_SOMEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aht"),
         dictgen::InsensitiveStr::Ascii("ere"),
@@ -37659,12 +37659,12 @@ pub static WORD_SOMEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SOMET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMET_CHILDREN),
+static WORD_SOMET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hibng"),
         dictgen::InsensitiveStr::Ascii("hig"),
@@ -37762,23 +37762,23 @@ pub static WORD_SOMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SOMES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMES_CHILDREN),
+static WORD_SOMES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMES_CHILDREN),
     value: Some(&["some", "sums"]),
 };
 
-pub static WORD_SOMES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SOMEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEO_CHILDREN),
+static WORD_SOMEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ene"),
@@ -37800,12 +37800,12 @@ pub static WORD_SOMEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SOMEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEN_CHILDREN),
+static WORD_SOMEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("one"),
@@ -37814,12 +37814,12 @@ pub static WORD_SOMEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_SOMEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEH_CHILDREN),
+static WORD_SOMEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ere"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -37845,34 +37845,34 @@ pub static WORD_SOMEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SOMEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEG_CHILDREN),
+static WORD_SOMEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hing")],
     values: &[&["something"]],
     range: 4..=4,
 };
 
-static WORD_SOMEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEB_CHILDREN),
+static WORD_SOMEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oby")],
     values: &[&["somebody"]],
     range: 3..=3,
 };
 
-static WORD_SOMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMA_CHILDREN),
+static WORD_SOMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ila"),
         dictgen::InsensitiveStr::Ascii("lija"),
@@ -37881,12 +37881,12 @@ pub static WORD_SOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOL_CHILDREN),
+static WORD_SOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("armutx"),
         dictgen::InsensitiveStr::Ascii("ataire"),
@@ -37994,12 +37994,12 @@ pub static WORD_SOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_SOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOK_CHILDREN),
+static WORD_SOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -38009,12 +38009,12 @@ pub static WORD_SOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_SOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOI_CHILDREN),
+static WORD_SOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("ld"),
@@ -38032,12 +38032,12 @@ pub static WORD_SOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOH_CHILDREN),
+static WORD_SOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pisticated"),
         dictgen::InsensitiveStr::Ascii("pomore"),
@@ -38047,12 +38047,12 @@ pub static WORD_SOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_SOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOF_CHILDREN),
+static WORD_SOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isticated"),
         dictgen::InsensitiveStr::Ascii("lty"),
@@ -38086,12 +38086,12 @@ pub static WORD_SOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOE_CHILDREN),
+static WORD_SOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cialize"),
         dictgen::InsensitiveStr::Ascii("m"),
@@ -38113,12 +38113,12 @@ pub static WORD_SOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOD_CHILDREN),
+static WORD_SOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("dered"),
@@ -38138,12 +38138,12 @@ pub static WORD_SOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SOC_CHILDREN),
+static WORD_SOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SOC_CHILDREN),
     value: None,
 };
 
-static WORD_SOC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SOC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SOCA_NODE),
     None,
     None,
@@ -38172,23 +38172,23 @@ static WORD_SOC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCT_CHILDREN),
+static WORD_SOCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tish")],
     values: &[&["scottish"]],
     range: 4..=4,
 };
 
-static WORD_SOCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCR_CHILDREN),
+static WORD_SOCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atease"),
         dictgen::InsensitiveStr::Ascii("atees"),
@@ -38212,23 +38212,23 @@ pub static WORD_SOCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SOCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCK_CHILDREN),
+static WORD_SOCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etted")],
     values: &[&["socketed"]],
     range: 5..=5,
 };
 
-static WORD_SOCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCI_CHILDREN),
+static WORD_SOCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alicing"),
         dictgen::InsensitiveStr::Ascii("alim"),
@@ -38320,12 +38320,12 @@ pub static WORD_SOCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SOCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCE_CHILDREN),
+static WORD_SOCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ities"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -38335,12 +38335,12 @@ pub static WORD_SOCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SOCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCA_CHILDREN),
+static WORD_SOCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("il"),
         dictgen::InsensitiveStr::Ascii("ilism"),
@@ -38372,12 +38372,12 @@ pub static WORD_SOCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOB_CHILDREN),
+static WORD_SOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erity"),
         dictgen::InsensitiveStr::Ascii("reity"),
@@ -38386,23 +38386,23 @@ pub static WORD_SOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_SOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOA_CHILDREN),
+static WORD_SOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lris")],
     values: &[&["solaris"]],
     range: 4..=4,
 };
 
-static WORD_SN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SN_CHILDREN),
+static WORD_SN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adler"),
         dictgen::InsensitiveStr::Ascii("adstorm"),
@@ -38512,12 +38512,12 @@ pub static WORD_SN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SM_CHILDREN),
+static WORD_SM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ackdwon"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -38589,12 +38589,12 @@ pub static WORD_SM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_SL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SL_CHILDREN),
+static WORD_SL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SL_CHILDREN),
     value: None,
 };
 
-static WORD_SL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SLA_NODE),
     None,
     Some(&WORD_SLC_NODE),
@@ -38623,12 +38623,12 @@ static WORD_SL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLU_CHILDREN),
+static WORD_SLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aghter"),
         dictgen::InsensitiveStr::Ascii("aghtered"),
@@ -38644,23 +38644,23 @@ pub static WORD_SLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_SLQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLQ_CHILDREN),
+static WORD_SLQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLQ_CHILDREN),
     value: Some(&["sql"]),
 };
 
-pub static WORD_SLQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLO_CHILDREN),
+static WORD_SLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gen"),
         dictgen::InsensitiveStr::Ascii("oth"),
@@ -38688,23 +38688,23 @@ pub static WORD_SLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_SLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLL_CHILDREN),
+static WORD_SLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ocation")],
     values: &[&["allocation"]],
     range: 7..=7,
 };
 
-static WORD_SLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLI_CHILDREN),
+static WORD_SLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -38754,23 +38754,23 @@ pub static WORD_SLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLG_CHILDREN),
+static WORD_SLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("htly")],
     values: &[&["slightly"]],
     range: 4..=4,
 };
 
-static WORD_SLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLE_CHILDREN),
+static WORD_SLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -38804,34 +38804,34 @@ pub static WORD_SLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SLD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLD_CHILDREN),
+static WORD_SLD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iers")],
     values: &[&["sliders"]],
     range: 4..=4,
 };
 
-static WORD_SLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLC_CHILDREN),
+static WORD_SLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["slices"]],
     range: 3..=3,
 };
 
-static WORD_SLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLA_CHILDREN),
+static WORD_SLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -38875,12 +38875,12 @@ pub static WORD_SLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_SK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SK_CHILDREN),
+static WORD_SK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SK_CHILDREN),
     value: None,
 };
 
-static WORD_SK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SK_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SKA_NODE),
     None,
     None,
@@ -38909,12 +38909,12 @@ static WORD_SK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SKY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKY_CHILDREN),
+static WORD_SKY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("walkr"),
@@ -38923,12 +38923,12 @@ pub static WORD_SKY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SKW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKW_CHILDREN),
+static WORD_SKW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alk"),
         dictgen::InsensitiveStr::Ascii("alked"),
@@ -38946,12 +38946,12 @@ pub static WORD_SKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SKU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKU_CHILDREN),
+static WORD_SKU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("rge"),
@@ -38969,12 +38969,12 @@ pub static WORD_SKU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SKT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKT_CHILDREN),
+static WORD_SKT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eches"),
         dictgen::InsensitiveStr::Ascii("echy"),
@@ -38983,12 +38983,12 @@ pub static WORD_SKT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_SKR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKR_CHILDREN),
+static WORD_SKR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("awberries"),
         dictgen::InsensitiveStr::Ascii("imish"),
@@ -38997,12 +38997,12 @@ pub static WORD_SKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_SKP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKP_CHILDREN),
+static WORD_SKP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etic"),
         dictgen::InsensitiveStr::Ascii("eticism"),
@@ -39012,12 +39012,12 @@ pub static WORD_SKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SKO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKO_CHILDREN),
+static WORD_SKO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ol"),
         dictgen::InsensitiveStr::Ascii("oled"),
@@ -39035,12 +39035,12 @@ pub static WORD_SKO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SKI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKI_CHILDREN),
+static WORD_SKI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfull"),
         dictgen::InsensitiveStr::Ascii("llfull"),
@@ -39102,12 +39102,12 @@ pub static WORD_SKI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SKE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKE_CHILDREN),
+static WORD_SKE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cth"),
         dictgen::InsensitiveStr::Ascii("cthes"),
@@ -39179,12 +39179,12 @@ pub static WORD_SKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SKA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKA_CHILDREN),
+static WORD_SKA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gerak"),
         dictgen::InsensitiveStr::Ascii("lar"),
@@ -39220,12 +39220,12 @@ pub static WORD_SKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_SI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SI_CHILDREN),
+static WORD_SI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SI_CHILDREN),
     value: None,
 };
 
-static WORD_SI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIA_NODE),
     Some(&WORD_SIB_NODE),
     Some(&WORD_SIC_NODE),
@@ -39254,12 +39254,12 @@ static WORD_SI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIZ_NODE),
 ];
 
-static WORD_SIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIZ_CHILDREN),
+static WORD_SIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIZ_CHILDREN),
     value: Some(&["six", "size"]),
 };
 
-pub static WORD_SIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebale"),
         dictgen::InsensitiveStr::Ascii("eble"),
@@ -39289,23 +39289,23 @@ pub static WORD_SIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=14,
 };
 
-static WORD_SIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIX_CHILDREN),
+static WORD_SIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tin")],
     values: &[&["sistine", "sixteen"]],
     range: 3..=3,
 };
 
-static WORD_SIW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIW_CHILDREN),
+static WORD_SIW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tch"),
         dictgen::InsensitiveStr::Ascii("tched"),
@@ -39316,12 +39316,12 @@ pub static WORD_SIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIV_CHILDREN),
+static WORD_SIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -39341,12 +39341,12 @@ pub static WORD_SIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_SIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIU_CHILDREN),
+static WORD_SIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tational"),
@@ -39356,12 +39356,12 @@ pub static WORD_SIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIT_CHILDREN),
+static WORD_SIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -39441,12 +39441,12 @@ pub static WORD_SIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_SIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIS_CHILDREN),
+static WORD_SIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("nce"),
@@ -39510,12 +39510,12 @@ pub static WORD_SIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_SIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIR_CHILDREN),
+static WORD_SIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cle"),
         dictgen::InsensitiveStr::Ascii("cles"),
@@ -39587,12 +39587,12 @@ pub static WORD_SIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_SIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIP_CHILDREN),
+static WORD_SIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ly"),
         dictgen::InsensitiveStr::Ascii("plies"),
@@ -39601,12 +39601,12 @@ pub static WORD_SIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIO_CHILDREN),
+static WORD_SIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nist"),
         dictgen::InsensitiveStr::Ascii("nists"),
@@ -39615,12 +39615,12 @@ pub static WORD_SIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_SIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SIN_CHILDREN),
+static WORD_SIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SIN_CHILDREN),
     value: None,
 };
 
-static WORD_SIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SINA_NODE),
     None,
     Some(&WORD_SINC_NODE),
@@ -39649,12 +39649,12 @@ static WORD_SIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINT_CHILDREN),
+static WORD_SINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ac"),
         dictgen::InsensitiveStr::Ascii("acks"),
@@ -39682,12 +39682,12 @@ pub static WORD_SINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINS_CHILDREN),
+static WORD_SINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("iter"),
@@ -39696,23 +39696,23 @@ pub static WORD_SINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SINP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINP_CHILDREN),
+static WORD_SINP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["simply"]],
     range: 2..=2,
 };
 
-static WORD_SINO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINO_CHILDREN),
+static WORD_SINO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("id"),
         dictgen::InsensitiveStr::Ascii("idal"),
@@ -39722,12 +39722,12 @@ pub static WORD_SINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SINN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINN_CHILDREN),
+static WORD_SINN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agog"),
         dictgen::InsensitiveStr::Ascii("agogs"),
@@ -39749,12 +39749,12 @@ pub static WORD_SINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SINL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINL_CHILDREN),
+static WORD_SINL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("geplayer"),
@@ -39764,12 +39764,12 @@ pub static WORD_SINL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_SINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINI_CHILDREN),
+static WORD_SINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cal"),
@@ -39791,12 +39791,12 @@ pub static WORD_SINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SING_CHILDREN),
+static WORD_SING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SING_CHILDREN),
     value: None,
 };
 
-pub static WORD_SING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -39922,23 +39922,23 @@ pub static WORD_SING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_SIND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIND_CHILDREN),
+static WORD_SIND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIND_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["since"]],
     range: 1..=1,
 };
 
-static WORD_SINC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINC_CHILDREN),
+static WORD_SINC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eer"),
         dictgen::InsensitiveStr::Ascii("ereley"),
@@ -39956,12 +39956,12 @@ pub static WORD_SINC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINA_CHILDREN),
+static WORD_SINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gog"),
         dictgen::InsensitiveStr::Ascii("gogs"),
@@ -39972,12 +39972,12 @@ pub static WORD_SINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SIM_CHILDREN),
+static WORD_SIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SIM_CHILDREN),
     value: None,
 };
 
-static WORD_SIM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SIM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIMA_NODE),
     None,
     None,
@@ -40006,12 +40006,12 @@ static WORD_SIM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SIMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMU_CHILDREN),
+static WORD_SIMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alte"),
         dictgen::InsensitiveStr::Ascii("alted"),
@@ -40133,23 +40133,23 @@ pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_SIMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMS_CHILDREN),
+static WORD_SIMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pon")],
     values: &[&["simpson"]],
     range: 3..=3,
 };
 
-static WORD_SIMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SIMP_CHILDREN),
+static WORD_SIMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SIMP_CHILDREN),
     value: None,
 };
 
-static WORD_SIMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SIMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIMPA_NODE),
     None,
     None,
@@ -40178,23 +40178,23 @@ static WORD_SIMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SIMPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPY_CHILDREN),
+static WORD_SIMPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPY_CHILDREN),
     value: Some(&["simply"]),
 };
 
-pub static WORD_SIMPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SIMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPT_CHILDREN),
+static WORD_SIMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("om"),
         dictgen::InsensitiveStr::Ascii("omatic"),
@@ -40230,23 +40230,23 @@ pub static WORD_SIMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SIMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPO_CHILDREN),
+static WORD_SIMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sn")],
     values: &[&["simpson"]],
     range: 2..=2,
 };
 
-static WORD_SIMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPL_CHILDREN),
+static WORD_SIMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efying"),
         dictgen::InsensitiveStr::Ascii("ei"),
@@ -40338,12 +40338,12 @@ pub static WORD_SIMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SIMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPI_CHILDREN),
+static WORD_SIMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("city"),
         dictgen::InsensitiveStr::Ascii("fication"),
@@ -40363,34 +40363,34 @@ pub static WORD_SIMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SIMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPE_CHILDREN),
+static WORD_SIMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lst")],
     values: &[&["simplest"]],
     range: 3..=3,
 };
 
-static WORD_SIMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPA_CHILDREN),
+static WORD_SIMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("thizers")],
     values: &[&["sympathizers"]],
     range: 7..=7,
 };
 
-static WORD_SIMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMM_CHILDREN),
+static WORD_SIMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etric"),
         dictgen::InsensitiveStr::Ascii("etrical"),
@@ -40412,12 +40412,12 @@ pub static WORD_SIMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_SIML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIML_CHILDREN),
+static WORD_SIML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIML_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("arlity"),
@@ -40473,12 +40473,12 @@ pub static WORD_SIML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SIMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMI_CHILDREN),
+static WORD_SIMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alir"),
         dictgen::InsensitiveStr::Ascii("alr"),
@@ -40562,23 +40562,23 @@ pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SIMG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMG_CHILDREN),
+static WORD_SIMG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["single"]],
     range: 2..=2,
 };
 
-static WORD_SIME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIME_CHILDREN),
+static WORD_SIME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIME_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ltaneous"),
         dictgen::InsensitiveStr::Ascii("ltaneously"),
@@ -40606,12 +40606,12 @@ pub static WORD_SIME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SIMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMA_CHILDREN),
+static WORD_SIMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ltaneous"),
         dictgen::InsensitiveStr::Ascii("ltaneously"),
@@ -40620,12 +40620,12 @@ pub static WORD_SIMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_SIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIL_CHILDREN),
+static WORD_SIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abus"),
         dictgen::InsensitiveStr::Ascii("abuses"),
@@ -40749,23 +40749,23 @@ pub static WORD_SIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_SIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIH_CHILDREN),
+static WORD_SIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("louette")],
     values: &[&["silhouette"]],
     range: 7..=7,
 };
 
-static WORD_SIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SIG_CHILDREN),
+static WORD_SIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SIG_CHILDREN),
     value: None,
 };
 
-static WORD_SIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SIG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIGA_NODE),
     None,
     None,
@@ -40794,12 +40794,12 @@ static WORD_SIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SIGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGU_CHILDREN),
+static WORD_SIGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ret"),
         dictgen::InsensitiveStr::Ascii("rete"),
@@ -40817,23 +40817,23 @@ pub static WORD_SIGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SIGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGT_CHILDREN),
+static WORD_SIGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hstone")],
     values: &[&["sightstone"]],
     range: 6..=6,
 };
 
-static WORD_SIGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGR_CHILDREN),
+static WORD_SIGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ynge"),
         dictgen::InsensitiveStr::Ascii("ynges"),
@@ -40842,12 +40842,12 @@ pub static WORD_SIGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_SIGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGN_CHILDREN),
+static WORD_SIGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abl"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -40967,12 +40967,12 @@ pub static WORD_SIGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SIGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGL_CHILDREN),
+static WORD_SIGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -40982,12 +40982,12 @@ pub static WORD_SIGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SIGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGI_CHILDREN),
+static WORD_SIGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ficance"),
         dictgen::InsensitiveStr::Ascii("ficant"),
@@ -41011,12 +41011,12 @@ pub static WORD_SIGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SIGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGH_CHILDREN),
+static WORD_SIGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("rynge"),
@@ -41036,23 +41036,23 @@ pub static WORD_SIGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SIGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGE_CHILDREN),
+static WORD_SIGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("n")],
     values: &[&["sign"]],
     range: 1..=1,
 };
 
-static WORD_SIGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGA_CHILDREN),
+static WORD_SIGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -41076,12 +41076,12 @@ pub static WORD_SIGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIF_CHILDREN),
+static WORD_SIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fix"),
         dictgen::InsensitiveStr::Ascii("fixation"),
@@ -41099,12 +41099,12 @@ pub static WORD_SIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_SIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIE_CHILDREN),
+static WORD_SIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIE_CHILDREN),
     value: Some(&["size", "sigh", "side"]),
 };
 
-pub static WORD_SIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nce"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -41132,12 +41132,12 @@ pub static WORD_SIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SID_CHILDREN),
+static WORD_SID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SID_CHILDREN),
     value: None,
 };
 
-pub static WORD_SID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ebaord"),
@@ -41165,12 +41165,12 @@ pub static WORD_SID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIC_CHILDREN),
+static WORD_SIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("inct"),
@@ -41190,12 +41190,12 @@ pub static WORD_SIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIB_CHILDREN),
+static WORD_SIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iling"),
         dictgen::InsensitiveStr::Ascii("ilings"),
@@ -41213,23 +41213,23 @@ pub static WORD_SIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_SIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIA_CHILDREN),
+static WORD_SIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["said"]],
     range: 1..=1,
 };
 
-static WORD_SH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SH_CHILDREN),
+static WORD_SH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SH_CHILDREN),
     value: None,
 };
 
-static WORD_SH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SHA_NODE),
     Some(&WORD_SHB_NODE),
     Some(&WORD_SHC_NODE),
@@ -41258,12 +41258,12 @@ static WORD_SH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHY_CHILDREN),
+static WORD_SHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stem"),
         dictgen::InsensitiveStr::Ascii("stemerror"),
@@ -41281,12 +41281,12 @@ pub static WORD_SHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_SHW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHW_CHILDREN),
+static WORD_SHW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ashank"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -41297,12 +41297,12 @@ pub static WORD_SHW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHU_CHILDREN),
+static WORD_SHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("down"),
         dictgen::InsensitiveStr::Ascii("fle"),
@@ -41336,12 +41336,12 @@ pub static WORD_SHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHT_CHILDREN),
+static WORD_SHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iless"),
         dictgen::InsensitiveStr::Ascii("op"),
@@ -41369,23 +41369,23 @@ pub static WORD_SHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SHS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHS_CHILDREN),
+static WORD_SHS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHS_CHILDREN),
     value: Some(&["nhs", "ssh"]),
 };
 
-pub static WORD_SHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pe")],
     values: &[&["shape"]],
     range: 2..=2,
 };
 
-static WORD_SHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHR_CHILDREN),
+static WORD_SHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apenl"),
         dictgen::InsensitiveStr::Ascii("eak"),
@@ -41411,12 +41411,12 @@ pub static WORD_SHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SHP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHP_CHILDREN),
+static WORD_SHP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -41442,12 +41442,12 @@ pub static WORD_SHP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SHO_CHILDREN),
+static WORD_SHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SHO_CHILDREN),
     value: None,
 };
 
-static WORD_SHO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SHO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -41476,12 +41476,12 @@ static WORD_SHO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SHOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOW_CHILDREN),
+static WORD_SHOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("boarding"),
         dictgen::InsensitiveStr::Ascii("ede"),
@@ -41499,12 +41499,12 @@ pub static WORD_SHOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SHOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOU_CHILDREN),
+static WORD_SHOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cl"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -41570,12 +41570,12 @@ pub static WORD_SHOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SHOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOT_CHILDREN),
+static WORD_SHOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cut"),
         dictgen::InsensitiveStr::Ascii("cuts"),
@@ -41586,12 +41586,12 @@ pub static WORD_SHOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SHOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOR_CHILDREN),
+static WORD_SHOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cut"),
         dictgen::InsensitiveStr::Ascii("cuts"),
@@ -41639,12 +41639,12 @@ pub static WORD_SHOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SHOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOP_CHILDREN),
+static WORD_SHOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("keeepers"),
@@ -41654,23 +41654,23 @@ pub static WORD_SHOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SHOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOO_CHILDREN),
+static WORD_SHOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uld")],
     values: &[&["should"]],
     range: 3..=3,
 };
 
-static WORD_SHOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOL_CHILDREN),
+static WORD_SHOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -41680,12 +41680,12 @@ pub static WORD_SHOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_SHOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOI_CHILDREN),
+static WORD_SHOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -41694,12 +41694,12 @@ pub static WORD_SHOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=2,
 };
 
-static WORD_SHOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOF_CHILDREN),
+static WORD_SHOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tware"),
@@ -41708,23 +41708,23 @@ pub static WORD_SHOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SHN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHN_CHILDREN),
+static WORD_SHN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aghai")],
     values: &[&["shanghai"]],
     range: 5..=5,
 };
 
-static WORD_SHL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHL_CHILDREN),
+static WORD_SHL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edon"),
         dictgen::InsensitiveStr::Ascii("eter"),
@@ -41742,12 +41742,12 @@ pub static WORD_SHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHI_CHILDREN),
+static WORD_SHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cane"),
         dictgen::InsensitiveStr::Ascii("eldd"),
@@ -41799,12 +41799,12 @@ pub static WORD_SHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SHF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHF_CHILDREN),
+static WORD_SHF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("ited"),
@@ -41824,12 +41824,12 @@ pub static WORD_SHF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SHE_CHILDREN),
+static WORD_SHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SHE_CHILDREN),
     value: None,
 };
 
-static WORD_SHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SHE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SHEA_NODE),
     Some(&WORD_SHEB_NODE),
     Some(&WORD_SHEC_NODE),
@@ -41858,23 +41858,23 @@ static WORD_SHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SHEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEV_CHILDREN),
+static WORD_SHEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("les")],
     values: &[&["shelves"]],
     range: 3..=3,
 };
 
-static WORD_SHET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHET_CHILDREN),
+static WORD_SHET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ler"),
         dictgen::InsensitiveStr::Ascii("lers"),
@@ -41883,12 +41883,12 @@ pub static WORD_SHET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SHER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHER_CHILDREN),
+static WORD_SHER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHER_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("if"),
         dictgen::InsensitiveStr::Ascii("ifs"),
@@ -41899,12 +41899,12 @@ pub static WORD_SHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SHEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEP_CHILDREN),
+static WORD_SHEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("arded"),
@@ -41952,12 +41952,12 @@ pub static WORD_SHEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SHEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEN_CHILDREN),
+static WORD_SHEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adigans"),
         dictgen::InsensitiveStr::Ascii("anagans"),
@@ -41995,12 +41995,12 @@ pub static WORD_SHEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_SHEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEM_CHILDREN),
+static WORD_SHEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("atic"),
@@ -42010,12 +42010,12 @@ pub static WORD_SHEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SHEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEL_CHILDREN),
+static WORD_SHEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("terd"),
         dictgen::InsensitiveStr::Ascii("vers"),
@@ -42025,12 +42025,12 @@ pub static WORD_SHEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_SHEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEI_CHILDREN),
+static WORD_SHEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("lded"),
@@ -42041,12 +42041,12 @@ pub static WORD_SHEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SHEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEE_CHILDREN),
+static WORD_SHEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lpe"),
         dictgen::InsensitiveStr::Ascii("pel"),
@@ -42064,12 +42064,12 @@ pub static WORD_SHEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SHED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHED_CHILDREN),
+static WORD_SHED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHED_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ule"),
         dictgen::InsensitiveStr::Ascii("uled"),
@@ -42087,12 +42087,12 @@ pub static WORD_SHED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SHEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEC_CHILDREN),
+static WORD_SHEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("k"),
         dictgen::InsensitiveStr::Ascii("ked"),
@@ -42110,23 +42110,23 @@ pub static WORD_SHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SHEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEB_CHILDREN),
+static WORD_SHEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eng")],
     values: &[&["shebang"]],
     range: 3..=3,
 };
 
-static WORD_SHEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEA_CHILDREN),
+static WORD_SHEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kspeare"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -42135,12 +42135,12 @@ pub static WORD_SHEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SHC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHC_CHILDREN),
+static WORD_SHC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edule"),
         dictgen::InsensitiveStr::Ascii("emes"),
@@ -42160,23 +42160,23 @@ pub static WORD_SHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_SHB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHB_CHILDREN),
+static WORD_SHB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ang")],
     values: &[&["shebang"]],
     range: 3..=3,
 };
 
-static WORD_SHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SHA_CHILDREN),
+static WORD_SHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SHA_CHILDREN),
     value: None,
 };
 
-static WORD_SHA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SHA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -42205,12 +42205,12 @@ static WORD_SHA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SHAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAW_CHILDREN),
+static WORD_SHAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hsank"),
         dictgen::InsensitiveStr::Ascii("shak"),
@@ -42219,12 +42219,12 @@ pub static WORD_SHAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_SHAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAT_CHILDREN),
+static WORD_SHAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nering"),
         dictgen::InsensitiveStr::Ascii("ow"),
@@ -42244,23 +42244,23 @@ pub static WORD_SHAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SHAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAS_CHILDREN),
+static WORD_SHAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hes")],
     values: &[&["slashes"]],
     range: 3..=3,
 };
 
-static WORD_SHAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAR_CHILDREN),
+static WORD_SHAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dholders"),
         dictgen::InsensitiveStr::Ascii("eed"),
@@ -42304,12 +42304,12 @@ pub static WORD_SHAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SHAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAP_CHILDREN),
+static WORD_SHAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ening"),
         dictgen::InsensitiveStr::Ascii("rening"),
@@ -42337,12 +42337,12 @@ pub static WORD_SHAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SHAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAO_CHILDREN),
+static WORD_SHAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dw"),
         dictgen::InsensitiveStr::Ascii("dws"),
@@ -42351,12 +42351,12 @@ pub static WORD_SHAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SHAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAN_CHILDREN),
+static WORD_SHAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deleer"),
         dictgen::InsensitiveStr::Ascii("deleers"),
@@ -42390,12 +42390,12 @@ pub static WORD_SHAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SHAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAM_CHILDREN),
+static WORD_SHAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elesly"),
         dictgen::InsensitiveStr::Ascii("elessely"),
@@ -42415,23 +42415,23 @@ pub static WORD_SHAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_SHAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAL_CHILDREN),
+static WORD_SHAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAL_CHILDREN),
     value: Some(&["shall"]),
 };
 
-pub static WORD_SHAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SHAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAK_CHILDREN),
+static WORD_SHAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eapeare"),
         dictgen::InsensitiveStr::Ascii("epseare"),
@@ -42453,23 +42453,23 @@ pub static WORD_SHAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_SHAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAE_CHILDREN),
+static WORD_SHAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rd")],
     values: &[&["shared", "shard"]],
     range: 2..=2,
 };
 
-static WORD_SHAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAD_CHILDREN),
+static WORD_SHAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asloo"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -42487,34 +42487,34 @@ pub static WORD_SHAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SG_CHILDREN),
+static WORD_SG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("adow")],
     values: &[&["shadow"]],
     range: 4..=4,
 };
 
-static WORD_SF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SF_CHILDREN),
+static WORD_SF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ety")],
     values: &[&["safety"]],
     range: 3..=3,
 };
 
-static WORD_SE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SE_CHILDREN),
+static WORD_SE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SE_CHILDREN),
     value: None,
 };
 
-static WORD_SE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SEA_NODE),
     Some(&WORD_SEB_NODE),
     Some(&WORD_SEC_NODE),
@@ -42543,12 +42543,12 @@ static WORD_SE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SEZ_NODE),
 ];
 
-static WORD_SEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEZ_CHILDREN),
+static WORD_SEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iure"),
         dictgen::InsensitiveStr::Ascii("iures"),
@@ -42558,12 +42558,12 @@ pub static WORD_SEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_SEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEX_CHILDREN),
+static WORD_SEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aulized"),
         dictgen::InsensitiveStr::Ascii("aully"),
@@ -42591,12 +42591,12 @@ pub static WORD_SEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_SEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEW_CHILDREN),
+static WORD_SEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("donim"),
         dictgen::InsensitiveStr::Ascii("donims"),
@@ -42606,12 +42606,12 @@ pub static WORD_SEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_SEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEV_CHILDREN),
+static WORD_SEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aral"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -42671,12 +42671,12 @@ pub static WORD_SEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_SEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEU_CHILDREN),
+static WORD_SEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ences"),
@@ -42694,12 +42694,12 @@ pub static WORD_SEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SET_CHILDREN),
+static WORD_SET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("evn"),
         dictgen::InsensitiveStr::Ascii("git"),
@@ -42785,12 +42785,12 @@ pub static WORD_SET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SES_CHILDREN),
+static WORD_SES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SES_CHILDREN),
     value: None,
 };
 
-pub static WORD_SES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cede"),
         dictgen::InsensitiveStr::Ascii("ceded"),
@@ -42852,12 +42852,12 @@ pub static WORD_SES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SER_CHILDREN),
+static WORD_SER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SER_CHILDREN),
     value: Some(&["set"]),
 };
 
-static WORD_SER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SERA_NODE),
     Some(&WORD_SERB_NODE),
     Some(&WORD_SERC_NODE),
@@ -42886,23 +42886,23 @@ static WORD_SER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERW_CHILDREN),
+static WORD_SERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["server", "sewer"]],
     range: 2..=2,
 };
 
-static WORD_SERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERV_CHILDREN),
+static WORD_SERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ans"),
         dictgen::InsensitiveStr::Ascii("antes"),
@@ -43000,12 +43000,12 @@ pub static WORD_SERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_SERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERT_CHILDREN),
+static WORD_SERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ificate"),
         dictgen::InsensitiveStr::Ascii("ificated"),
@@ -43021,23 +43021,23 @@ pub static WORD_SERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_SERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERS_CHILDREN),
+static WORD_SERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["series"]],
     range: 3..=3,
 };
 
-static WORD_SERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERR_CHILDREN),
+static WORD_SERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebral"),
         dictgen::InsensitiveStr::Ascii("ebrally"),
@@ -43046,12 +43046,12 @@ pub static WORD_SERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_SERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERO_CHILDREN),
+static WORD_SERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("und"),
         dictgen::InsensitiveStr::Ascii("unded"),
@@ -43067,12 +43067,12 @@ pub static WORD_SERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERI_CHILDREN),
+static WORD_SERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aized"),
         dictgen::InsensitiveStr::Ascii("alialisation"),
@@ -43188,12 +43188,12 @@ pub static WORD_SERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_SERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERG_CHILDREN),
+static WORD_SERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aent"),
         dictgen::InsensitiveStr::Ascii("eat"),
@@ -43211,12 +43211,12 @@ pub static WORD_SERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERE_CHILDREN),
+static WORD_SERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bral"),
         dictgen::InsensitiveStr::Ascii("brally"),
@@ -43244,12 +43244,12 @@ pub static WORD_SERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERC_CHILDREN),
+static WORD_SERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hable"),
@@ -43279,23 +43279,23 @@ pub static WORD_SERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERB_CHILDREN),
+static WORD_SERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ain")],
     values: &[&["serbian"]],
     range: 3..=3,
 };
 
-static WORD_SERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERA_CHILDREN),
+static WORD_SERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -43363,12 +43363,12 @@ pub static WORD_SERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEQ_CHILDREN),
+static WORD_SEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -43480,12 +43480,12 @@ pub static WORD_SEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_SEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SEP_CHILDREN),
+static WORD_SEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SEP_CHILDREN),
     value: None,
 };
 
-static WORD_SEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SEP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SEPA_NODE),
     None,
     Some(&WORD_SEPC_NODE),
@@ -43514,12 +43514,12 @@ static WORD_SEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SEPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPU_CHILDREN),
+static WORD_SEPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lchraly"),
         dictgen::InsensitiveStr::Ascii("lchrlly"),
@@ -43537,12 +43537,12 @@ pub static WORD_SEPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SEPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPT_CHILDREN),
+static WORD_SEPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emer"),
         dictgen::InsensitiveStr::Ascii("meber"),
@@ -43551,12 +43551,12 @@ pub static WORD_SEPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_SEPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPR_CHILDREN),
+static WORD_SEPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aate"),
         dictgen::InsensitiveStr::Ascii("arate"),
@@ -43578,12 +43578,12 @@ pub static WORD_SEPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SEPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPP_CHILDREN),
+static WORD_SEPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("arations"),
@@ -43593,23 +43593,23 @@ pub static WORD_SEPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_SEPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPO_CHILDREN),
+static WORD_SEPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rate")],
     values: &[&["separate"]],
     range: 4..=4,
 };
 
-static WORD_SEPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPL_CHILDREN),
+static WORD_SEPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icural"),
         dictgen::InsensitiveStr::Ascii("icurally"),
@@ -43627,23 +43627,23 @@ pub static WORD_SEPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_SEPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPI_CHILDREN),
+static WORD_SEPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("na")],
     values: &[&["subpena"]],
     range: 2..=2,
 };
 
-static WORD_SEPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SEPE_CHILDREN),
+static WORD_SEPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SEPE_CHILDREN),
     value: None,
 };
 
-static WORD_SEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SEPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SEPEA_NODE),
     None,
     Some(&WORD_SEPEC_NODE),
@@ -43672,12 +43672,12 @@ static WORD_SEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SEPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPET_CHILDREN),
+static WORD_SEPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aror"),
         dictgen::InsensitiveStr::Ascii("arors"),
@@ -43697,12 +43697,12 @@ pub static WORD_SEPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SEPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPER_CHILDREN),
+static WORD_SEPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ad"),
@@ -43812,12 +43812,12 @@ pub static WORD_SEPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SEPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPEN_CHILDREN),
+static WORD_SEPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dent"),
@@ -43827,23 +43827,23 @@ pub static WORD_SEPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SEPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPEI_CHILDREN),
+static WORD_SEPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cfy")],
     values: &[&["specify"]],
     range: 3..=3,
 };
 
-static WORD_SEPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPEC_CHILDREN),
+static WORD_SEPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("ially"),
@@ -43873,12 +43873,12 @@ pub static WORD_SEPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SEPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPEA_CHILDREN),
+static WORD_SEPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rable"),
         dictgen::InsensitiveStr::Ascii("rate"),
@@ -43928,12 +43928,12 @@ pub static WORD_SEPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SEPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPC_CHILDREN),
+static WORD_SEPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("ially"),
@@ -43965,12 +43965,12 @@ pub static WORD_SEPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SEPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPA_CHILDREN),
+static WORD_SEPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("racion"),
@@ -44050,12 +44050,12 @@ pub static WORD_SEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEO_CHILDREN),
+static WORD_SEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("nds"),
@@ -44064,12 +44064,12 @@ pub static WORD_SEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_SEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SEN_CHILDREN),
+static WORD_SEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SEN_CHILDREN),
     value: None,
 };
 
-static WORD_SEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SENA_NODE),
     None,
     Some(&WORD_SENC_NODE),
@@ -44098,12 +44098,12 @@ static WORD_SEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SENZ_NODE),
 ];
 
-static WORD_SENZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENZ_CHILDREN),
+static WORD_SENZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ationalism"),
         dictgen::InsensitiveStr::Ascii("ationalist"),
@@ -44112,12 +44112,12 @@ pub static WORD_SENZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 10..=10,
 };
 
-static WORD_SENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENT_CHILDREN),
+static WORD_SENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amental"),
         dictgen::InsensitiveStr::Ascii("aments"),
@@ -44207,12 +44207,12 @@ pub static WORD_SENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SENS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENS_CHILDREN),
+static WORD_SENS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -44332,34 +44332,34 @@ pub static WORD_SENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_SENQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENQ_CHILDREN),
+static WORD_SENQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uence")],
     values: &[&["sequence"]],
     range: 5..=5,
 };
 
-static WORD_SENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENO_CHILDREN),
+static WORD_SENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("irs")],
     values: &[&["seniors"]],
     range: 3..=3,
 };
 
-static WORD_SENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENI_CHILDREN),
+static WORD_SENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntels"),
         dictgen::InsensitiveStr::Ascii("ores"),
@@ -44381,23 +44381,23 @@ pub static WORD_SENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENF_CHILDREN),
+static WORD_SENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ile")],
     values: &[&["sendfile"]],
     range: 3..=3,
 };
 
-static WORD_SENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENE_CHILDREN),
+static WORD_SENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rio"),
         dictgen::InsensitiveStr::Ascii("rity"),
@@ -44406,12 +44406,12 @@ pub static WORD_SENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEND_CHILDREN),
+static WORD_SEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etary"),
         dictgen::InsensitiveStr::Ascii("ign"),
@@ -44422,12 +44422,12 @@ pub static WORD_SEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENC_CHILDREN),
+static WORD_SENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ond"),
@@ -44443,12 +44443,12 @@ pub static WORD_SENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENA_CHILDREN),
+static WORD_SENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ireo"),
         dictgen::InsensitiveStr::Ascii("ireos"),
@@ -44474,12 +44474,12 @@ pub static WORD_SENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEM_CHILDREN),
+static WORD_SEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aintics"),
         dictgen::InsensitiveStr::Ascii("amphore"),
@@ -44577,12 +44577,12 @@ pub static WORD_SEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_SEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEL_CHILDREN),
+static WORD_SEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceted"),
         dictgen::InsensitiveStr::Ascii("cetion"),
@@ -44700,12 +44700,12 @@ pub static WORD_SEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_SEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEK_CHILDREN),
+static WORD_SEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -44715,12 +44715,12 @@ pub static WORD_SEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_SEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEI_CHILDREN),
+static WORD_SEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("na"),
@@ -44742,23 +44742,23 @@ pub static WORD_SEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_SEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEH_CHILDREN),
+static WORD_SEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEH_CHILDREN),
     value: Some(&["she"]),
 };
 
-pub static WORD_SEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ll")],
     values: &[&["sell", "shell"]],
     range: 2..=2,
 };
 
-static WORD_SEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEG_CHILDREN),
+static WORD_SEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("aults"),
@@ -44864,12 +44864,12 @@ pub static WORD_SEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_SEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEF_CHILDREN),
+static WORD_SEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lies"),
         dictgen::InsensitiveStr::Ascii("lishness"),
@@ -44878,12 +44878,12 @@ pub static WORD_SEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_SEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEE_CHILDREN),
+static WORD_SEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("em"),
@@ -44949,12 +44949,12 @@ pub static WORD_SEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_SED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SED_CHILDREN),
+static WORD_SED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SED_CHILDREN),
     value: None,
 };
 
-pub static WORD_SED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entarity"),
         dictgen::InsensitiveStr::Ascii("ereal"),
@@ -44976,12 +44976,12 @@ pub static WORD_SED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_SEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SEC_CHILDREN),
+static WORD_SEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SEC_CHILDREN),
     value: None,
 };
 
-static WORD_SEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_SECC_NODE),
@@ -45010,12 +45010,12 @@ static WORD_SEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECU_CHILDREN),
+static WORD_SECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -45067,12 +45067,12 @@ pub static WORD_SECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECT_CHILDREN),
+static WORD_SECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ins"),
@@ -45114,12 +45114,12 @@ pub static WORD_SECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECR_CHILDREN),
+static WORD_SECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atary"),
         dictgen::InsensitiveStr::Ascii("atery"),
@@ -45151,34 +45151,34 @@ pub static WORD_SECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SECQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECQ_CHILDREN),
+static WORD_SECQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uence")],
     values: &[&["sequence"]],
     range: 5..=5,
 };
 
-static WORD_SECP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECP_CHILDREN),
+static WORD_SECP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["scepter"]],
     range: 3..=3,
 };
 
-static WORD_SECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECO_CHILDREN),
+static WORD_SECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -45236,12 +45236,12 @@ pub static WORD_SECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SECN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECN_CHILDREN),
+static WORD_SECN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -45250,23 +45250,23 @@ pub static WORD_SECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=1,
 };
 
-static WORD_SECL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECL_CHILDREN),
+static WORD_SECL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ector")],
     values: &[&["selector"]],
     range: 5..=5,
 };
 
-static WORD_SECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECI_CHILDREN),
+static WORD_SECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fic"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -45288,12 +45288,12 @@ pub static WORD_SECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECE_CHILDREN),
+static WORD_SECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eded"),
@@ -45313,12 +45313,12 @@ pub static WORD_SECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECC_CHILDREN),
+static WORD_SECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eeded"),
         dictgen::InsensitiveStr::Ascii("ond"),
@@ -45336,12 +45336,12 @@ pub static WORD_SECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEB_CHILDREN),
+static WORD_SEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asitan"),
         dictgen::InsensitiveStr::Ascii("astain"),
@@ -45361,12 +45361,12 @@ pub static WORD_SEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEA_CHILDREN),
+static WORD_SEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -45426,12 +45426,12 @@ pub static WORD_SEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SC_CHILDREN),
+static WORD_SC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SC_CHILDREN),
     value: None,
 };
 
-static WORD_SC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SCA_NODE),
     None,
     Some(&WORD_SCC_NODE),
@@ -45460,23 +45460,23 @@ static WORD_SC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SCY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCY_CHILDREN),
+static WORD_SCY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hter")],
     values: &[&["scyther"]],
     range: 4..=4,
 };
 
-static WORD_SCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCU_CHILDREN),
+static WORD_SCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bscribe"),
         dictgen::InsensitiveStr::Ascii("bscribed"),
@@ -45528,12 +45528,12 @@ pub static WORD_SCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_SCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCT_CHILDREN),
+static WORD_SCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -45569,12 +45569,12 @@ pub static WORD_SCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_SCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SCR_CHILDREN),
+static WORD_SCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SCR_CHILDREN),
     value: None,
 };
 
-static WORD_SCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SCR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SCRA_NODE),
     None,
     None,
@@ -45603,12 +45603,12 @@ static WORD_SCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SCRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRU_CHILDREN),
+static WORD_SCRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bed"),
         dictgen::InsensitiveStr::Ascii("itny"),
@@ -45628,12 +45628,12 @@ pub static WORD_SCRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SCRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRT_CHILDREN),
+static WORD_SCRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ip"),
         dictgen::InsensitiveStr::Ascii("iped"),
@@ -45644,23 +45644,23 @@ pub static WORD_SCRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SCRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRR_CHILDREN),
+static WORD_SCRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("en")],
     values: &[&["screen"]],
     range: 2..=2,
 };
 
-static WORD_SCRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRP_CHILDREN),
+static WORD_SCRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("ited"),
@@ -45684,12 +45684,12 @@ pub static WORD_SCRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SCRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRO_CHILDREN),
+static WORD_SCRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("ipt"),
@@ -45727,12 +45727,12 @@ pub static WORD_SCRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SCRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRI_CHILDREN),
+static WORD_SCRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipt"),
         dictgen::InsensitiveStr::Ascii("ipted"),
@@ -45802,12 +45802,12 @@ pub static WORD_SCRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SCRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRE_CHILDREN),
+static WORD_SCRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eb"),
         dictgen::InsensitiveStr::Ascii("ebs"),
@@ -45849,12 +45849,12 @@ pub static WORD_SCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SCRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRA_CHILDREN),
+static WORD_SCRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -45896,23 +45896,23 @@ pub static WORD_SCRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCP_CHILDREN),
+static WORD_SCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eter")],
     values: &[&["scepter"]],
     range: 4..=4,
 };
 
-static WORD_SCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCO_CHILDREN),
+static WORD_SCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ket"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -45970,12 +45970,12 @@ pub static WORD_SCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SCN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCN_CHILDREN),
+static WORD_SCN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adinavia"),
         dictgen::InsensitiveStr::Ascii("adinavian"),
@@ -45991,12 +45991,12 @@ pub static WORD_SCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_SCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCL_CHILDREN),
+static WORD_SCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("ar"),
@@ -46006,12 +46006,12 @@ pub static WORD_SCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCK_CHILDREN),
+static WORD_SCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etch"),
         dictgen::InsensitiveStr::Ascii("etched"),
@@ -46022,12 +46022,12 @@ pub static WORD_SCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCI_CHILDREN),
+static WORD_SCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encers"),
         dictgen::InsensitiveStr::Ascii("encists"),
@@ -46109,12 +46109,12 @@ pub static WORD_SCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_SCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SCH_CHILDREN),
+static WORD_SCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SCH_CHILDREN),
     value: None,
 };
 
-static WORD_SCH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SCH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_SCHC_NODE),
@@ -46143,12 +46143,12 @@ static WORD_SCH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SCHZ_NODE),
 ];
 
-static WORD_SCHZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHZ_CHILDREN),
+static WORD_SCHZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iophrenia"),
         dictgen::InsensitiveStr::Ascii("iophrenic"),
@@ -46157,12 +46157,12 @@ pub static WORD_SCHZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=9,
 };
 
-static WORD_SCHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHY_CHILDREN),
+static WORD_SCHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("zophrenia"),
         dictgen::InsensitiveStr::Ascii("zophrenic"),
@@ -46171,23 +46171,23 @@ pub static WORD_SCHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=9,
 };
 
-static WORD_SCHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHU_CHILDREN),
+static WORD_SCHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dule")],
     values: &[&["schedule"]],
     range: 4..=4,
 };
 
-static WORD_SCHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHO_CHILDREN),
+static WORD_SCHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alrs"),
         dictgen::InsensitiveStr::Ascii("alrship"),
@@ -46237,12 +46237,12 @@ pub static WORD_SCHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_SCHM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHM_CHILDREN),
+static WORD_SCHM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ea"),
@@ -46253,12 +46253,12 @@ pub static WORD_SCHM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_SCHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHI_CHILDREN),
+static WORD_SCHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sophrenic"),
         dictgen::InsensitiveStr::Ascii("ziphrenic"),
@@ -46286,12 +46286,12 @@ pub static WORD_SCHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=11,
 };
 
-static WORD_SCHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHE_CHILDREN),
+static WORD_SCHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("dual"),
@@ -46347,12 +46347,12 @@ pub static WORD_SCHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SCHD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHD_CHILDREN),
+static WORD_SCHD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eule"),
         dictgen::InsensitiveStr::Ascii("ule"),
@@ -46374,23 +46374,23 @@ pub static WORD_SCHD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SCHC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHC_CHILDREN),
+static WORD_SCHC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ema")],
     values: &[&["schema"]],
     range: 3..=3,
 };
 
-static WORD_SCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCE_CHILDREN),
+static WORD_SCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anrio"),
         dictgen::InsensitiveStr::Ascii("anrios"),
@@ -46466,12 +46466,12 @@ pub static WORD_SCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_SCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCC_CHILDREN),
+static WORD_SCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("esses"),
@@ -46499,12 +46499,12 @@ pub static WORD_SCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_SCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SCA_CHILDREN),
+static WORD_SCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SCA_CHILDREN),
     value: None,
 };
 
-static WORD_SCA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SCA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -46533,12 +46533,12 @@ static WORD_SCA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SCAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAV_CHILDREN),
+static WORD_SCAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("anged"),
@@ -46556,12 +46556,12 @@ pub static WORD_SCAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_SCAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAT_CHILDREN),
+static WORD_SCAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -46587,12 +46587,12 @@ pub static WORD_SCAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SCAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAR_CHILDREN),
+static WORD_SCAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amento"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -46628,12 +46628,12 @@ pub static WORD_SCAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SCAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAN_CHILDREN),
+static WORD_SCAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dales"),
         dictgen::InsensitiveStr::Ascii("dalos"),
@@ -46715,12 +46715,12 @@ pub static WORD_SCAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SCAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAL_CHILDREN),
+static WORD_SCAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("arizaiton"),
@@ -46742,23 +46742,23 @@ pub static WORD_SCAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SCAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAH_CHILDREN),
+static WORD_SCAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["schar"]],
     range: 1..=1,
 };
 
-static WORD_SCAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAF_CHILDREN),
+static WORD_SCAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("old"),
         dictgen::InsensitiveStr::Ascii("olded"),
@@ -46778,34 +46778,34 @@ pub static WORD_SCAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SCAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAE_CHILDREN),
+static WORD_SCAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pgoat")],
     values: &[&["scapegoat"]],
     range: 5..=5,
 };
 
-static WORD_SB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SB_CHILDREN),
+static WORD_SB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sampling")],
     values: &[&["subsampling"]],
     range: 8..=8,
 };
 
-static WORD_SA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SA_CHILDREN),
+static WORD_SA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SA_CHILDREN),
     value: None,
 };
 
-static WORD_SA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SAA_NODE),
     Some(&WORD_SAB_NODE),
     Some(&WORD_SAC_NODE),
@@ -46834,23 +46834,23 @@ static WORD_SA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAX_CHILDREN),
+static WORD_SAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aphone")],
     values: &[&["saxophone"]],
     range: 6..=6,
 };
 
-static WORD_SAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAW_CHILDREN),
+static WORD_SAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nsea"),
         dictgen::InsensitiveStr::Ascii("nson"),
@@ -46884,12 +46884,12 @@ pub static WORD_SAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAV_CHILDREN),
+static WORD_SAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAV_CHILDREN),
     value: Some(&["save"]),
 };
 
-pub static WORD_SAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anha"),
         dictgen::InsensitiveStr::Ascii("annh"),
@@ -46925,12 +46925,12 @@ pub static WORD_SAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAU_CHILDREN),
+static WORD_SAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ght"),
         dictgen::InsensitiveStr::Ascii("tay"),
@@ -46950,12 +46950,12 @@ pub static WORD_SAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SAT_CHILDREN),
+static WORD_SAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SAT_CHILDREN),
     value: None,
 };
 
-static WORD_SAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SATA_NODE),
     None,
     None,
@@ -46984,23 +46984,23 @@ static WORD_SAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SATY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATY_CHILDREN),
+static WORD_SATY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATY_CHILDREN),
     value: Some(&["stay"]),
 };
 
-pub static WORD_SATY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATU_CHILDREN),
+static WORD_SATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aday"),
         dictgen::InsensitiveStr::Ascii("adays"),
@@ -47024,12 +47024,12 @@ pub static WORD_SATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATT_CHILDREN),
+static WORD_SATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elit"),
         dictgen::InsensitiveStr::Ascii("elite"),
@@ -47051,12 +47051,12 @@ pub static WORD_SATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATS_CHILDREN),
+static WORD_SATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifaction"),
         dictgen::InsensitiveStr::Ascii("ifactory"),
@@ -47078,12 +47078,12 @@ pub static WORD_SATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATR_CHILDREN),
+static WORD_SATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -47103,12 +47103,12 @@ pub static WORD_SATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATI_CHILDREN),
+static WORD_SATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -47182,12 +47182,12 @@ pub static WORD_SATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_SATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATE_CHILDREN),
+static WORD_SATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ful"),
         dictgen::InsensitiveStr::Ascii("lite"),
@@ -47217,12 +47217,12 @@ pub static WORD_SATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATA_CHILDREN),
+static WORD_SATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndard"),
         dictgen::InsensitiveStr::Ascii("ndards"),
@@ -47238,12 +47238,12 @@ pub static WORD_SATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_SAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAS_CHILDREN),
+static WORD_SAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("auges"),
         dictgen::InsensitiveStr::Ascii("catchewan"),
@@ -47287,12 +47287,12 @@ pub static WORD_SAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_SAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAR_CHILDREN),
+static WORD_SAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cams"),
         dictgen::InsensitiveStr::Ascii("casam"),
@@ -47348,12 +47348,12 @@ pub static WORD_SAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_SAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAP_CHILDREN),
+static WORD_SAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cebar"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -47383,12 +47383,12 @@ pub static WORD_SAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_SAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAN_CHILDREN),
+static WORD_SAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aty"),
         dictgen::InsensitiveStr::Ascii("bdox"),
@@ -47504,12 +47504,12 @@ pub static WORD_SAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_SAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAM_CHILDREN),
+static WORD_SAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aphore"),
         dictgen::InsensitiveStr::Ascii("aphores"),
@@ -47557,12 +47557,12 @@ pub static WORD_SAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAL_CHILDREN),
+static WORD_SAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aires"),
         dictgen::InsensitiveStr::Ascii("aris"),
@@ -47592,45 +47592,45 @@ pub static WORD_SAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAK_CHILDREN),
+static WORD_SAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("satchewan")],
     values: &[&["saskatchewan"]],
     range: 9..=9,
 };
 
-static WORD_SAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAI_CHILDREN),
+static WORD_SAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["says"]],
     range: 1..=1,
 };
 
-static WORD_SAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAH_CHILDREN),
+static WORD_SAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("re")],
     values: &[&["share"]],
     range: 2..=2,
 };
 
-static WORD_SAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAG_CHILDREN),
+static WORD_SAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gital"),
         dictgen::InsensitiveStr::Ascii("ital"),
@@ -47640,12 +47640,12 @@ pub static WORD_SAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAF_CHILDREN),
+static WORD_SAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eguared"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -47673,12 +47673,12 @@ pub static WORD_SAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAE_CHILDREN),
+static WORD_SAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("rching"),
@@ -47687,12 +47687,12 @@ pub static WORD_SAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAD_CHILDREN),
+static WORD_SAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dends"),
         dictgen::InsensitiveStr::Ascii("denes"),
@@ -47720,12 +47720,12 @@ pub static WORD_SAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAC_CHILDREN),
+static WORD_SAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alar"),
         dictgen::InsensitiveStr::Ascii("alars"),
@@ -47821,12 +47821,12 @@ pub static WORD_SAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAB_CHILDREN),
+static WORD_SAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atage"),
         dictgen::InsensitiveStr::Ascii("atosh"),
@@ -47848,12 +47848,12 @@ pub static WORD_SAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_SAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAA_CHILDREN),
+static WORD_SAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("me"),
         dictgen::InsensitiveStr::Ascii("ndbox"),
@@ -47862,12 +47862,12 @@ pub static WORD_SAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_R_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_R_CHILDREN),
+static WORD_R_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_R_CHILDREN),
     value: None,
 };
 
-static WORD_R_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_R_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RA_NODE),
     None,
     Some(&WORD_RC_NODE),
@@ -47896,12 +47896,12 @@ static WORD_R_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RY_CHILDREN),
+static WORD_RY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enolds"),
         dictgen::InsensitiveStr::Ascii("ou"),
@@ -47929,23 +47929,23 @@ pub static WORD_RY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_RW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RW_CHILDREN),
+static WORD_RW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RW_CHILDREN),
     value: None,
 };
 
-pub static WORD_RW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ite")],
     values: &[&["write"]],
     range: 3..=3,
 };
 
-static WORD_RU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RU_CHILDREN),
+static WORD_RU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("barb"),
         dictgen::InsensitiveStr::Ascii("cuperate"),
@@ -48041,12 +48041,12 @@ pub static WORD_RU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_RT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RT_CHILDREN),
+static WORD_RT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -48066,12 +48066,12 @@ pub static WORD_RT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_RS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RS_CHILDREN),
+static WORD_RS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eolution"),
         dictgen::InsensitiveStr::Ascii("icv"),
@@ -48093,12 +48093,12 @@ pub static WORD_RS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_RR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RR_CHILDREN),
+static WORD_RR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anslation"),
         dictgen::InsensitiveStr::Ascii("anslations"),
@@ -48124,12 +48124,12 @@ pub static WORD_RR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_RQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RQ_CHILDREN),
+static WORD_RQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euest"),
         dictgen::InsensitiveStr::Ascii("euested"),
@@ -48163,23 +48163,23 @@ pub static WORD_RQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_RP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RP_CHILDREN),
+static WORD_RP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lace")],
     values: &[&["replace"]],
     range: 4..=4,
 };
 
-static WORD_RO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RO_CHILDREN),
+static WORD_RO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RO_CHILDREN),
     value: None,
 };
 
-static WORD_RO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ROA_NODE),
     Some(&WORD_ROB_NODE),
     Some(&WORD_ROC_NODE),
@@ -48208,12 +48208,12 @@ static WORD_RO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ROY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROY_CHILDREN),
+static WORD_ROY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alites"),
         dictgen::InsensitiveStr::Ascii("laties"),
@@ -48222,12 +48222,12 @@ pub static WORD_ROY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=6,
 };
 
-static WORD_ROV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROV_CHILDREN),
+static WORD_ROV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ide"),
         dictgen::InsensitiveStr::Ascii("ided"),
@@ -48245,12 +48245,12 @@ pub static WORD_ROV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROU_CHILDREN),
+static WORD_ROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("ghtly"),
@@ -48318,12 +48318,12 @@ pub static WORD_ROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ROT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROT_CHILDREN),
+static WORD_ROT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aion"),
         dictgen::InsensitiveStr::Ascii("aions"),
@@ -48363,12 +48363,12 @@ pub static WORD_ROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ROS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROS_CHILDREN),
+static WORD_ROS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ettta"),
         dictgen::InsensitiveStr::Ascii("ponse"),
@@ -48379,23 +48379,23 @@ pub static WORD_ROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_ROR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROR_CHILDREN),
+static WORD_ROR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ated")],
     values: &[&["rotated"]],
     range: 4..=4,
 };
 
-static WORD_ROP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROP_CHILDREN),
+static WORD_ROP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eat"),
         dictgen::InsensitiveStr::Ascii("ository"),
@@ -48404,12 +48404,12 @@ pub static WORD_ROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_ROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROO_CHILDREN),
+static WORD_ROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mate"),
         dictgen::InsensitiveStr::Ascii("mates"),
@@ -48418,12 +48418,12 @@ pub static WORD_ROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_RON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RON_CHILDREN),
+static WORD_RON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RON_CHILDREN),
     value: None,
 };
 
-pub static WORD_RON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dayvoo"),
         dictgen::InsensitiveStr::Ascii("dayvooed"),
@@ -48447,12 +48447,12 @@ pub static WORD_RON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_ROM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROM_CHILDREN),
+static WORD_ROM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aanin"),
         dictgen::InsensitiveStr::Ascii("aina"),
@@ -48498,12 +48498,12 @@ pub static WORD_ROM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ROL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROL_CHILDREN),
+static WORD_ROL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("epaly"),
         dictgen::InsensitiveStr::Ascii("epalying"),
@@ -48537,12 +48537,12 @@ pub static WORD_ROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ROI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROI_CHILDREN),
+static WORD_ROI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gin"),
         dictgen::InsensitiveStr::Ascii("ginal"),
@@ -48564,12 +48564,12 @@ pub static WORD_ROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ROG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROG_CHILDREN),
+static WORD_ROG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anism"),
         dictgen::InsensitiveStr::Ascii("anisms"),
@@ -48579,12 +48579,12 @@ pub static WORD_ROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ROE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROE_CHILDREN),
+static WORD_ROE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lplay"),
         dictgen::InsensitiveStr::Ascii("ls"),
@@ -48594,12 +48594,12 @@ pub static WORD_ROE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ROD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROD_CHILDREN),
+static WORD_ROD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uce"),
         dictgen::InsensitiveStr::Ascii("uceer"),
@@ -48608,12 +48608,12 @@ pub static WORD_ROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROC_CHILDREN),
+static WORD_ROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("kerfeller"),
@@ -48639,12 +48639,12 @@ pub static WORD_ROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROB_CHILDREN),
+static WORD_ROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("berts"),
         dictgen::InsensitiveStr::Ascii("berys"),
@@ -48672,12 +48672,12 @@ pub static WORD_ROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_ROA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROA_CHILDREN),
+static WORD_ROA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chers"),
         dictgen::InsensitiveStr::Ascii("hces"),
@@ -48701,12 +48701,12 @@ pub static WORD_ROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_RN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RN_CHILDREN),
+static WORD_RN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ger"),
@@ -48716,12 +48716,12 @@ pub static WORD_RN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_RM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RM_CHILDREN),
+static WORD_RM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eote"),
         dictgen::InsensitiveStr::Ascii("eove"),
@@ -48743,12 +48743,12 @@ pub static WORD_RM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_RL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RL_CHILDREN),
+static WORD_RL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -48758,12 +48758,12 @@ pub static WORD_RL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_RI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RI_CHILDREN),
+static WORD_RI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RI_CHILDREN),
     value: None,
 };
 
-static WORD_RI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RIA_NODE),
     None,
     Some(&WORD_RIC_NODE),
@@ -48792,23 +48792,23 @@ static WORD_RI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_RIZ_NODE),
 ];
 
-static WORD_RIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIZ_CHILDREN),
+static WORD_RIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["rises"]],
     range: 2..=2,
 };
 
-static WORD_RIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIV_CHILDREN),
+static WORD_RIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alrly"),
         dictgen::InsensitiveStr::Ascii("arlies"),
@@ -48830,12 +48830,12 @@ pub static WORD_RIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_RIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIT_CHILDREN),
+static WORD_RIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("alian"),
@@ -48869,12 +48869,12 @@ pub static WORD_RIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_RIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIS_CHILDREN),
+static WORD_RIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("kay"),
@@ -48894,12 +48894,12 @@ pub static WORD_RIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_RIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIN_CHILDREN),
+static WORD_RIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gotne"),
         dictgen::InsensitiveStr::Ascii("inging"),
@@ -48917,12 +48917,12 @@ pub static WORD_RIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_RIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIM_CHILDREN),
+static WORD_RIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aniss"),
         dictgen::InsensitiveStr::Ascii("anissed"),
@@ -48960,23 +48960,23 @@ pub static WORD_RIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_RIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIL_CHILDREN),
+static WORD_RIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("varies")],
     values: &[&["rivalries"]],
     range: 6..=6,
 };
 
-static WORD_RIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIG_CHILDREN),
+static WORD_RIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -49036,12 +49036,12 @@ pub static WORD_RIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_RIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIE_CHILDREN),
+static WORD_RIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndeer"),
         dictgen::InsensitiveStr::Ascii("ndeers"),
@@ -49059,12 +49059,12 @@ pub static WORD_RIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_RID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RID_CHILDREN),
+static WORD_RID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RID_CHILDREN),
     value: None,
 };
 
-pub static WORD_RID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icilous"),
         dictgen::InsensitiveStr::Ascii("icilously"),
@@ -49110,12 +49110,12 @@ pub static WORD_RID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=12,
 };
 
-static WORD_RIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIC_CHILDREN),
+static WORD_RIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hochet"),
         dictgen::InsensitiveStr::Ascii("hochets"),
@@ -49137,23 +49137,23 @@ pub static WORD_RIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_RIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIA_CHILDREN),
+static WORD_RIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ders")],
     values: &[&["raiders"]],
     range: 4..=4,
 };
 
-static WORD_RH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RH_CHILDREN),
+static WORD_RH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aposdy"),
         dictgen::InsensitiveStr::Ascii("apsodomy"),
@@ -49197,12 +49197,12 @@ pub static WORD_RH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_RG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RG_CHILDREN),
+static WORD_RG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eards"),
         dictgen::InsensitiveStr::Ascii("ister"),
@@ -49212,12 +49212,12 @@ pub static WORD_RG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_RF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RF_CHILDREN),
+static WORD_RF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erence"),
         dictgen::InsensitiveStr::Ascii("erences"),
@@ -49227,12 +49227,12 @@ pub static WORD_RF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_RE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RE_CHILDREN),
+static WORD_RE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RE_CHILDREN),
     value: None,
 };
 
-static WORD_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REA_NODE),
     Some(&WORD_REB_NODE),
     Some(&WORD_REC_NODE),
@@ -49261,23 +49261,23 @@ static WORD_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_REZ_NODE),
 ];
 
-static WORD_REZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REZ_CHILDREN),
+static WORD_REZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("urrection")],
     values: &[&["resurrection"]],
     range: 9..=9,
 };
 
-static WORD_REY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REY_CHILDREN),
+static WORD_REY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REY_CHILDREN),
     value: None,
 };
 
-pub static WORD_REY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nlods"),
         dictgen::InsensitiveStr::Ascii("nols"),
@@ -49287,12 +49287,12 @@ pub static WORD_REY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_REW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REW_CHILDREN),
+static WORD_REW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REW_CHILDREN),
     value: None,
 };
 
-pub static WORD_REW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achted"),
         dictgen::InsensitiveStr::Ascii("arching"),
@@ -49358,12 +49358,12 @@ pub static WORD_REW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_REV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REV_CHILDREN),
+static WORD_REV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REV_CHILDREN),
     value: None,
 };
 
-static WORD_REV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REVA_NODE),
     None,
     None,
@@ -49392,12 +49392,12 @@ static WORD_REV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVS_CHILDREN),
+static WORD_REVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erse"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -49407,12 +49407,12 @@ pub static WORD_REVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVR_CHILDREN),
+static WORD_REVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ese"),
         dictgen::InsensitiveStr::Ascii("ieve"),
@@ -49432,12 +49432,12 @@ pub static WORD_REVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVO_CHILDREN),
+static WORD_REVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("kation"),
@@ -49523,12 +49523,12 @@ pub static WORD_REVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_REVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVL_CHILDREN),
+static WORD_REVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alidation"),
         dictgen::InsensitiveStr::Ascii("over"),
@@ -49538,12 +49538,12 @@ pub static WORD_REVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_REVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVI_CHILDREN),
+static WORD_REVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ere"),
         dictgen::InsensitiveStr::Ascii("ewd"),
@@ -49593,12 +49593,12 @@ pub static WORD_REVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVE_CHILDREN),
+static WORD_REVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ald"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -49704,12 +49704,12 @@ pub static WORD_REVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_REVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVA_CHILDREN),
+static WORD_REVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ildating"),
         dictgen::InsensitiveStr::Ascii("luated"),
@@ -49718,12 +49718,12 @@ pub static WORD_REVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_REU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REU_CHILDREN),
+static WORD_REU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asble"),
         dictgen::InsensitiveStr::Ascii("dce"),
@@ -49839,12 +49839,12 @@ pub static WORD_REU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_RET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RET_CHILDREN),
+static WORD_RET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RET_CHILDREN),
     value: None,
 };
 
-static WORD_RET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RET_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RETA_NODE),
     None,
     Some(&WORD_RETC_NODE),
@@ -49873,12 +49873,12 @@ static WORD_RET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RETY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETY_CHILDREN),
+static WORD_RETY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETY_CHILDREN),
     value: Some(&["retry"]),
 };
 
-pub static WORD_RETY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rable"),
         dictgen::InsensitiveStr::Ascii("ring"),
@@ -49887,12 +49887,12 @@ pub static WORD_RETY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_RETU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETU_CHILDREN),
+static WORD_RETU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("end"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -49966,12 +49966,12 @@ pub static WORD_RETU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RETS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETS_CHILDREN),
+static WORD_RETS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("art"),
         dictgen::InsensitiveStr::Ascii("arts"),
@@ -49980,12 +49980,12 @@ pub static WORD_RETS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_RETR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RETR_CHILDREN),
+static WORD_RETR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RETR_CHILDREN),
     value: None,
 };
 
-static WORD_RETR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RETR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RETRA_NODE),
     None,
     None,
@@ -50014,12 +50014,12 @@ static WORD_RETR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RETRV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRV_CHILDREN),
+static WORD_RETRV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ieve"),
         dictgen::InsensitiveStr::Ascii("ieved"),
@@ -50037,12 +50037,12 @@ pub static WORD_RETRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_RETRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRU_CHILDREN),
+static WORD_RETRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bution"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -50062,12 +50062,12 @@ pub static WORD_RETRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RETRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRO_CHILDREN),
+static WORD_RETRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("activelly"),
         dictgen::InsensitiveStr::Ascii("activily"),
@@ -50091,12 +50091,12 @@ pub static WORD_RETRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_RETRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRN_CHILDREN),
+static WORD_RETRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRN_CHILDREN),
     value: Some(&["return"]),
 };
 
-pub static WORD_RETRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -50105,12 +50105,12 @@ pub static WORD_RETRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_RETRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRI_CHILDREN),
+static WORD_RETRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bucion"),
         dictgen::InsensitiveStr::Ascii("buito"),
@@ -50158,12 +50158,12 @@ pub static WORD_RETRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_RETRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRE_CHILDREN),
+static WORD_RETRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aving"),
         dictgen::InsensitiveStr::Ascii("bution"),
@@ -50215,12 +50215,12 @@ pub static WORD_RETRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RETRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRA_CHILDREN),
+static WORD_RETRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nser"),
         dictgen::InsensitiveStr::Ascii("nsferd"),
@@ -50244,12 +50244,12 @@ pub static WORD_RETRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_RETQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETQ_CHILDREN),
+static WORD_RETQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uirement"),
         dictgen::InsensitiveStr::Ascii("uirements"),
@@ -50269,23 +50269,23 @@ pub static WORD_RETQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_RETP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETP_CHILDREN),
+static WORD_RETP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("resenting")],
     values: &[&["representing"]],
     range: 9..=9,
 };
 
-static WORD_RETO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETO_CHILDREN),
+static WORD_RETO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ractively"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -50309,12 +50309,12 @@ pub static WORD_RETO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RETI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETI_CHILDREN),
+static WORD_RETI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erment"),
         dictgen::InsensitiveStr::Ascii("eval"),
@@ -50362,12 +50362,12 @@ pub static WORD_RETI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RETH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETH_CHILDREN),
+static WORD_RETH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("oric"),
@@ -50377,12 +50377,12 @@ pub static WORD_RETH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RETE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETE_CHILDREN),
+static WORD_RETE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("river"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -50396,12 +50396,12 @@ pub static WORD_RETE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RETC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETC_CHILDREN),
+static WORD_RETC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ieve"),
         dictgen::InsensitiveStr::Ascii("ieved"),
@@ -50419,12 +50419,12 @@ pub static WORD_RETC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_RETA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETA_CHILDREN),
+static WORD_RETA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilate"),
         dictgen::InsensitiveStr::Ascii("ilation"),
@@ -50476,12 +50476,12 @@ pub static WORD_RETA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RES_CHILDREN),
+static WORD_RES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RES_CHILDREN),
     value: None,
 };
 
-static WORD_RES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RESA_NODE),
     None,
     Some(&WORD_RESC_NODE),
@@ -50510,34 +50510,34 @@ static WORD_RES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESY_CHILDREN),
+static WORD_RESY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cn")],
     values: &[&["resync"]],
     range: 2..=2,
 };
 
-static WORD_RESV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESV_CHILDREN),
+static WORD_RESV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olved")],
     values: &[&["resolved"]],
     range: 5..=5,
 };
 
-static WORD_RESU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESU_CHILDREN),
+static WORD_RESU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -50649,12 +50649,12 @@ pub static WORD_RESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_REST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REST_CHILDREN),
+static WORD_REST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REST_CHILDREN),
     value: None,
 };
 
-static WORD_REST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RESTA_NODE),
     None,
     None,
@@ -50683,12 +50683,12 @@ static WORD_REST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTU_CHILDREN),
+static WORD_RESTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arant"),
         dictgen::InsensitiveStr::Ascii("arants"),
@@ -50724,12 +50724,12 @@ pub static WORD_RESTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_RESTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTR_CHILDREN),
+static WORD_RESTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aind"),
         dictgen::InsensitiveStr::Ascii("aing"),
@@ -50829,12 +50829,12 @@ pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RESTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTO_CHILDREN),
+static WORD_RESTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("iring"),
@@ -50870,12 +50870,12 @@ pub static WORD_RESTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_RESTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTI_CHILDREN),
+static WORD_RESTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cted"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -50909,12 +50909,12 @@ pub static WORD_RESTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_RESTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTE_CHILDREN),
+static WORD_RESTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("raunt"),
         dictgen::InsensitiveStr::Ascii("raunts"),
@@ -50930,12 +50930,12 @@ pub static WORD_RESTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RESTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTA_CHILDREN),
+static WORD_RESTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nti"),
         dictgen::InsensitiveStr::Ascii("rant"),
@@ -50987,12 +50987,12 @@ pub static WORD_RESTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_RESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESS_CHILDREN),
+static WORD_RESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apee"),
         dictgen::InsensitiveStr::Ascii("emblance"),
@@ -51064,12 +51064,12 @@ pub static WORD_RESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RESR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESR_CHILDREN),
+static WORD_RESR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ouce"),
         dictgen::InsensitiveStr::Ascii("ouced"),
@@ -51087,23 +51087,23 @@ pub static WORD_RESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_RESQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESQ_CHILDREN),
+static WORD_RESQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uest")],
     values: &[&["request"]],
     range: 4..=4,
 };
 
-static WORD_RESP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RESP_CHILDREN),
+static WORD_RESP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RESP_CHILDREN),
     value: None,
 };
 
-static WORD_RESP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RESP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RESPA_NODE),
     None,
     None,
@@ -51132,12 +51132,12 @@ static WORD_RESP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESPW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPW_CHILDREN),
+static WORD_RESPW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPW_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("aned"),
@@ -51148,23 +51148,23 @@ pub static WORD_RESPW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RESPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPS_CHILDREN),
+static WORD_RESPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ectively")],
     values: &[&["respectively"]],
     range: 8..=8,
 };
 
-static WORD_RESPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPR_CHILDREN),
+static WORD_RESPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esent"),
         dictgen::InsensitiveStr::Ascii("esentation"),
@@ -51188,12 +51188,12 @@ pub static WORD_RESPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=12,
 };
 
-static WORD_RESPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPP_CHILDREN),
+static WORD_RESPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onse"),
         dictgen::InsensitiveStr::Ascii("onses"),
@@ -51202,12 +51202,12 @@ pub static WORD_RESPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_RESPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RESPO_CHILDREN),
+static WORD_RESPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RESPO_CHILDREN),
     value: None,
 };
 
-static WORD_RESPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RESPO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -51236,12 +51236,12 @@ static WORD_RESPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESPOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOT_CHILDREN),
+static WORD_RESPOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -51250,12 +51250,12 @@ pub static WORD_RESPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_RESPOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOS_CHILDREN),
+static WORD_RESPOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -51285,23 +51285,23 @@ pub static WORD_RESPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_RESPOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOR_CHILDREN),
+static WORD_RESPOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atory")],
     values: &[&["respiratory"]],
     range: 5..=5,
 };
 
-static WORD_RESPON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RESPON_CHILDREN),
+static WORD_RESPON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RESPON_CHILDREN),
     value: None,
 };
 
-static WORD_RESPON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RESPON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_RESPONC_NODE),
@@ -51330,12 +51330,12 @@ static WORD_RESPON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESPONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONS_CHILDREN),
+static WORD_RESPONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONS_CHILDREN),
     value: Some(&["response", "respond"]),
 };
 
-pub static WORD_RESPONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abile"),
         dictgen::InsensitiveStr::Ascii("abilities"),
@@ -51423,23 +51423,23 @@ pub static WORD_RESPONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=10,
 };
 
-static WORD_RESPONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONN_CHILDREN),
+static WORD_RESPONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sibilty")],
     values: &[&["responsibility"]],
     range: 7..=7,
 };
 
-static WORD_RESPONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONI_CHILDREN),
+static WORD_RESPONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilities"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -51461,12 +51461,12 @@ pub static WORD_RESPONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=9,
 };
 
-static WORD_RESPONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONE_CHILDREN),
+static WORD_RESPONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONE_CHILDREN),
     value: Some(&["response", "respond"]),
 };
 
-pub static WORD_RESPONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -51475,12 +51475,12 @@ pub static WORD_RESPONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=1,
 };
 
-static WORD_RESPOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOND_CHILDREN),
+static WORD_RESPOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -51500,12 +51500,12 @@ pub static WORD_RESPOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=4,
 };
 
-static WORD_RESPONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONC_CHILDREN),
+static WORD_RESPONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONC_CHILDREN),
     value: Some(&["response", "respond"]),
 };
 
-pub static WORD_RESPONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -51527,23 +51527,23 @@ pub static WORD_RESPONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_RESPOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOD_CHILDREN),
+static WORD_RESPOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uce")],
     values: &[&["reproduce"]],
     range: 3..=3,
 };
 
-static WORD_RESPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPN_CHILDREN),
+static WORD_RESPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -51552,12 +51552,12 @@ pub static WORD_RESPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_RESPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPI_CHILDREN),
+static WORD_RESPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ratiory"),
         dictgen::InsensitiveStr::Ascii("ratoy"),
@@ -51573,12 +51573,12 @@ pub static WORD_RESPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_RESPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPE_CHILDREN),
+static WORD_RESPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("catble"),
         dictgen::InsensitiveStr::Ascii("citve"),
@@ -51642,23 +51642,23 @@ pub static WORD_RESPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RESPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPA_CHILDREN),
+static WORD_RESPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("wining")],
     values: &[&["respawning"]],
     range: 6..=6,
 };
 
-static WORD_RESO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RESO_CHILDREN),
+static WORD_RESO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RESO_CHILDREN),
     value: None,
 };
 
-static WORD_RESO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RESO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -51687,12 +51687,12 @@ static WORD_RESO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOV_CHILDREN),
+static WORD_RESOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("lable"),
@@ -51716,12 +51716,12 @@ pub static WORD_RESOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RESOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOU_CHILDREN),
+static WORD_RESOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -51771,12 +51771,12 @@ pub static WORD_RESOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RESOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOT_CHILDREN),
+static WORD_RESOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ration"),
         dictgen::InsensitiveStr::Ascii("rations"),
@@ -51802,12 +51802,12 @@ pub static WORD_RESOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_RESOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOR_CHILDREN),
+static WORD_RESOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -51839,12 +51839,12 @@ pub static WORD_RESOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RESOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOP_CHILDREN),
+static WORD_RESOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nse"),
         dictgen::InsensitiveStr::Ascii("nses"),
@@ -51854,12 +51854,12 @@ pub static WORD_RESOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_RESOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOO_CHILDREN),
+static WORD_RESOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("urce"),
         dictgen::InsensitiveStr::Ascii("urced"),
@@ -51875,12 +51875,12 @@ pub static WORD_RESOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_RESON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESON_CHILDREN),
+static WORD_RESON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESON_CHILDREN),
     value: Some(&["reason"]),
 };
 
-pub static WORD_RESON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abelt"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -51902,12 +51902,12 @@ pub static WORD_RESON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RESOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOL_CHILDREN),
+static WORD_RESOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -51961,12 +51961,12 @@ pub static WORD_RESOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_RESOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOI_CHILDREN),
+static WORD_RESOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("urce"),
         dictgen::InsensitiveStr::Ascii("urced"),
@@ -51982,12 +51982,12 @@ pub static WORD_RESOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_RESOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOE_CHILDREN),
+static WORD_RESOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -51996,12 +51996,12 @@ pub static WORD_RESOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RESM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESM_CHILDREN),
+static WORD_RESM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eble"),
         dictgen::InsensitiveStr::Ascii("ebles"),
@@ -52010,12 +52010,12 @@ pub static WORD_RESM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_RESL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESL_CHILDREN),
+static WORD_RESL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ection"),
         dictgen::InsensitiveStr::Ascii("ove"),
@@ -52039,12 +52039,12 @@ pub static WORD_RESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RESI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESI_CHILDREN),
+static WORD_RESI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dencial"),
         dictgen::InsensitiveStr::Ascii("dentail"),
@@ -52144,23 +52144,23 @@ pub static WORD_RESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_RESH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESH_CHILDREN),
+static WORD_RESH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("edule")],
     values: &[&["reschedule"]],
     range: 5..=5,
 };
 
-static WORD_RESG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESG_CHILDREN),
+static WORD_RESG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ination"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -52176,12 +52176,12 @@ pub static WORD_RESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_RESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESE_CHILDREN),
+static WORD_RESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -52305,12 +52305,12 @@ pub static WORD_RESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RESC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESC_CHILDREN),
+static WORD_RESC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aned"),
         dictgen::InsensitiveStr::Ascii("edule"),
@@ -52344,12 +52344,12 @@ pub static WORD_RESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESA_CHILDREN),
+static WORD_RESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erch"),
         dictgen::InsensitiveStr::Ascii("ons"),
@@ -52375,12 +52375,12 @@ pub static WORD_RESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RER_CHILDREN),
+static WORD_RER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RER_CHILDREN),
     value: None,
 };
 
-pub static WORD_RER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eated"),
         dictgen::InsensitiveStr::Ascii("egisteration"),
@@ -52420,12 +52420,12 @@ pub static WORD_RER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_REQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REQ_CHILDREN),
+static WORD_REQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REQ_CHILDREN),
     value: None,
 };
 
-static WORD_REQ_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REQ_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -52454,12 +52454,12 @@ static WORD_REQ_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REQU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REQU_CHILDREN),
+static WORD_REQU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REQU_CHILDREN),
     value: None,
 };
 
-static WORD_REQU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REQU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -52488,12 +52488,12 @@ static WORD_REQU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REQUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQUS_CHILDREN),
+static WORD_REQUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ite"),
@@ -52515,12 +52515,12 @@ pub static WORD_REQUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_REQUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQUR_CHILDREN),
+static WORD_REQUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -52566,12 +52566,12 @@ pub static WORD_REQUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REQUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQUI_CHILDREN),
+static WORD_REQUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ements"),
@@ -52651,12 +52651,12 @@ pub static WORD_REQUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REQUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQUE_CHILDREN),
+static WORD_REQUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("im"),
@@ -52720,12 +52720,12 @@ pub static WORD_REQUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_REQR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQR_CHILDREN),
+static WORD_REQR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ite"),
         dictgen::InsensitiveStr::Ascii("ites"),
@@ -52735,23 +52735,23 @@ pub static WORD_REQR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_REQQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQQ_CHILDREN),
+static WORD_REQQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uests")],
     values: &[&["requests"]],
     range: 5..=5,
 };
 
-static WORD_REQI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQI_CHILDREN),
+static WORD_REQI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -52793,12 +52793,12 @@ pub static WORD_REQI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REQE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQE_CHILDREN),
+static WORD_REQE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("st"),
         dictgen::InsensitiveStr::Ascii("sted"),
@@ -52822,12 +52822,12 @@ pub static WORD_REQE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_REP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REP_CHILDREN),
+static WORD_REP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REP_CHILDREN),
     value: None,
 };
 
-static WORD_REP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPA_NODE),
     Some(&WORD_REPB_NODE),
     None,
@@ -52856,12 +52856,12 @@ static WORD_REP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPU_CHILDREN),
+static WORD_REPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bic"),
         dictgen::InsensitiveStr::Ascii("bican"),
@@ -52931,12 +52931,12 @@ pub static WORD_REPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPT_CHILDREN),
+static WORD_REPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iel"),
         dictgen::InsensitiveStr::Ascii("ils"),
@@ -52954,12 +52954,12 @@ pub static WORD_REPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPS_CHILDREN),
+static WORD_REPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("awn"),
         dictgen::InsensitiveStr::Ascii("ectable"),
@@ -53017,12 +53017,12 @@ pub static WORD_REPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_REPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPR_CHILDREN),
+static WORD_REPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPR_CHILDREN),
     value: None,
 };
 
-static WORD_REPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPRA_NODE),
     None,
     None,
@@ -53051,34 +53051,34 @@ static WORD_REPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRU_CHILDREN),
+static WORD_REPRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cible")],
     values: &[&["reproducible"]],
     range: 5..=5,
 };
 
-static WORD_REPRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRT_CHILDREN),
+static WORD_REPRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oire")],
     values: &[&["repertoire"]],
     range: 4..=4,
 };
 
-static WORD_REPRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRS_CHILDREN),
+static WORD_REPRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -53098,12 +53098,12 @@ pub static WORD_REPRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_REPRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRO_CHILDREN),
+static WORD_REPRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciblbe"),
         dictgen::InsensitiveStr::Ascii("cible"),
@@ -53187,12 +53187,12 @@ pub static WORD_REPRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_REPRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRI_CHILDREN),
+static WORD_REPRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cussions"),
         dictgen::InsensitiveStr::Ascii("hensible"),
@@ -53201,23 +53201,23 @@ pub static WORD_REPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=8,
 };
 
-static WORD_REPRH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRH_CHILDREN),
+static WORD_REPRH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRH_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ase")],
     values: &[&["rephrase"]],
     range: 3..=3,
 };
 
-static WORD_REPRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPRE_CHILDREN),
+static WORD_REPRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPRE_CHILDREN),
     value: None,
 };
 
-static WORD_REPRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_REPREC_NODE),
@@ -53246,23 +53246,23 @@ static WORD_REPRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPREZ_NODE),
 ];
 
-static WORD_REPREZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREZ_CHILDREN),
+static WORD_REPREZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("entative")],
     values: &[&["representative"]],
     range: 8..=8,
 };
 
-static WORD_REPRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPRES_CHILDREN),
+static WORD_REPRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPRES_CHILDREN),
     value: None,
 };
 
-static WORD_REPRES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPRES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPRESA_NODE),
     None,
     None,
@@ -53291,12 +53291,12 @@ static WORD_REPRES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPRESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRESS_CHILDREN),
+static WORD_REPRESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -53322,12 +53322,12 @@ pub static WORD_REPRESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_REPRESN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRESN_CHILDREN),
+static WORD_REPRESN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRESN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRESN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etated"),
@@ -53361,12 +53361,12 @@ pub static WORD_REPRESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_REPRESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRESE_CHILDREN),
+static WORD_REPRESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("natation"),
         dictgen::InsensitiveStr::Ascii("natational"),
@@ -53488,12 +53488,12 @@ pub static WORD_REPRESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=10,
 };
 
-static WORD_REPRESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRESA_CHILDREN),
+static WORD_REPRESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("ntation"),
@@ -53519,23 +53519,23 @@ pub static WORD_REPRESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=9,
 };
 
-static WORD_REPREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREP_CHILDREN),
+static WORD_REPREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("resents")],
     values: &[&["represents"]],
     range: 7..=7,
 };
 
-static WORD_REPREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREN_CHILDREN),
+static WORD_REPREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sent"),
         dictgen::InsensitiveStr::Ascii("sentation"),
@@ -53561,12 +53561,12 @@ pub static WORD_REPREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_REPREH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREH_CHILDREN),
+static WORD_REPREH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREH_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enisble"),
         dictgen::InsensitiveStr::Ascii("ensable"),
@@ -53576,12 +53576,12 @@ pub static WORD_REPREH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=7,
 };
 
-static WORD_REPREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREE_CHILDREN),
+static WORD_REPREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("snt"),
         dictgen::InsensitiveStr::Ascii("snted"),
@@ -53591,12 +53591,12 @@ pub static WORD_REPREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_REPREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREC_CHILDREN),
+static WORD_REPREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ussion"),
         dictgen::InsensitiveStr::Ascii("ussions"),
@@ -53605,12 +53605,12 @@ pub static WORD_REPREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=7,
 };
 
-static WORD_REPRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRA_CHILDREN),
+static WORD_REPRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esentation"),
         dictgen::InsensitiveStr::Ascii("esentational"),
@@ -53626,12 +53626,12 @@ pub static WORD_REPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_REPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPP_CHILDREN),
+static WORD_REPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ository"),
@@ -53640,12 +53640,12 @@ pub static WORD_REPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_REPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPO_CHILDREN),
+static WORD_REPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("erter"),
@@ -53779,12 +53779,12 @@ pub static WORD_REPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_REPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPL_CHILDREN),
+static WORD_REPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPL_CHILDREN),
     value: None,
 };
 
-static WORD_REPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPLA_NODE),
     None,
     Some(&WORD_REPLC_NODE),
@@ -53813,12 +53813,12 @@ static WORD_REPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLY_CHILDREN),
+static WORD_REPLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ign"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -53827,12 +53827,12 @@ pub static WORD_REPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_REPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLU_CHILDREN),
+static WORD_REPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bic"),
         dictgen::InsensitiveStr::Ascii("sive"),
@@ -53841,23 +53841,23 @@ pub static WORD_REPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REPLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLO_CHILDREN),
+static WORD_REPLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ying")],
     values: &[&["redeploying"]],
     range: 4..=4,
 };
 
-static WORD_REPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLI_CHILDREN),
+static WORD_REPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cae"),
         dictgen::InsensitiveStr::Ascii("caes"),
@@ -53893,12 +53893,12 @@ pub static WORD_REPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REPLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLE_CHILDREN),
+static WORD_REPLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acable"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -53920,12 +53920,12 @@ pub static WORD_REPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_REPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLC_CHILDREN),
+static WORD_REPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -53943,12 +53943,12 @@ pub static WORD_REPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLA_CHILDREN),
+static WORD_REPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ca"),
         dictgen::InsensitiveStr::Ascii("cability"),
@@ -54050,12 +54050,12 @@ pub static WORD_REPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPI_CHILDREN),
+static WORD_REPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("lcas"),
@@ -54081,12 +54081,12 @@ pub static WORD_REPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_REPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPH_CHILDREN),
+static WORD_REPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arse"),
         dictgen::InsensitiveStr::Ascii("rasse"),
@@ -54095,12 +54095,12 @@ pub static WORD_REPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_REPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPE_CHILDREN),
+static WORD_REPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPE_CHILDREN),
     value: None,
 };
 
-static WORD_REPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPEA_NODE),
     None,
     Some(&WORD_REPEC_NODE),
@@ -54129,12 +54129,12 @@ static WORD_REPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPET_CHILDREN),
+static WORD_REPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPET_CHILDREN),
     value: Some(&["repeat"]),
 };
 
-pub static WORD_REPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -54174,12 +54174,12 @@ pub static WORD_REPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_REPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPES_CHILDREN),
+static WORD_REPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -54199,12 +54199,12 @@ pub static WORD_REPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_REPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPER_CHILDREN),
+static WORD_REPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esent"),
         dictgen::InsensitiveStr::Ascii("esentation"),
@@ -54244,12 +54244,12 @@ pub static WORD_REPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_REPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEN_CHILDREN),
+static WORD_REPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tence"),
@@ -54259,12 +54259,12 @@ pub static WORD_REPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_REPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEL_CHILDREN),
+static WORD_REPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ases"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -54284,23 +54284,23 @@ pub static WORD_REPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_REPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEI_CHILDREN),
+static WORD_REPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["repetition"]],
     range: 4..=4,
 };
 
-static WORD_REPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPED_CHILDREN),
+static WORD_REPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -54310,12 +54310,12 @@ pub static WORD_REPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_REPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEC_CHILDREN),
+static WORD_REPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("table"),
@@ -54337,12 +54337,12 @@ pub static WORD_REPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_REPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEA_CHILDREN),
+static WORD_REPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dedly"),
         dictgen::InsensitiveStr::Ascii("detly"),
@@ -54386,12 +54386,12 @@ pub static WORD_REPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPB_CHILDREN),
+static WORD_REPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lic"),
         dictgen::InsensitiveStr::Ascii("lican"),
@@ -54413,12 +54413,12 @@ pub static WORD_REPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_REPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPA_CHILDREN),
+static WORD_REPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -54502,12 +54502,12 @@ pub static WORD_REPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_REO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REO_CHILDREN),
+static WORD_REO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("admap"),
         dictgen::InsensitiveStr::Ascii("ccuring"),
@@ -54581,12 +54581,12 @@ pub static WORD_REO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_REN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REN_CHILDREN),
+static WORD_REN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REN_CHILDREN),
     value: None,
 };
 
-static WORD_REN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENA_NODE),
     None,
     None,
@@ -54615,23 +54615,23 @@ static WORD_REN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENY_CHILDREN),
+static WORD_RENY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olds")],
     values: &[&["reynolds"]],
     range: 4..=4,
 };
 
-static WORD_RENW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENW_CHILDREN),
+static WORD_RENW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENW_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("eables"),
@@ -54640,23 +54640,23 @@ pub static WORD_RENW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RENU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENU_CHILDREN),
+static WORD_RENU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ion")],
     values: &[&["reunion"]],
     range: 3..=3,
 };
 
-static WORD_RENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENT_CHILDREN),
+static WORD_RENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eris"),
         dictgen::InsensitiveStr::Ascii("ime"),
@@ -54667,12 +54667,12 @@ pub static WORD_RENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_RENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENO_CHILDREN),
+static WORD_RENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sance"),
         dictgen::InsensitiveStr::Ascii("un"),
@@ -54688,12 +54688,12 @@ pub static WORD_RENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENN_CHILDREN),
+static WORD_RENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aisance"),
         dictgen::InsensitiveStr::Ascii("ovate"),
@@ -54711,12 +54711,12 @@ pub static WORD_RENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_RENM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENM_CHILDREN),
+static WORD_RENM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -54725,23 +54725,23 @@ pub static WORD_RENM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_RENK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENK_CHILDREN),
+static WORD_RENK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENK_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eton")],
     values: &[&["renekton"]],
     range: 4..=4,
 };
 
-static WORD_RENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENI_CHILDREN),
+static WORD_RENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("assance"),
         dictgen::InsensitiveStr::Ascii("forcements"),
@@ -54761,23 +54761,23 @@ pub static WORD_RENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_RENG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENG_CHILDREN),
+static WORD_RENG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enerate")],
     values: &[&["regenerate"]],
     range: 7..=7,
 };
 
-static WORD_RENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENF_CHILDREN),
+static WORD_RENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erence"),
         dictgen::InsensitiveStr::Ascii("orce"),
@@ -54797,12 +54797,12 @@ pub static WORD_RENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_RENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENE_CHILDREN),
+static WORD_RENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENE_CHILDREN),
     value: None,
 };
 
-static WORD_RENE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEA_NODE),
     None,
     None,
@@ -54831,12 +54831,12 @@ static WORD_RENE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEW_CHILDREN),
+static WORD_RENEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("abels"),
@@ -54854,23 +54854,23 @@ pub static WORD_RENEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RENET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENET_CHILDREN),
+static WORD_RENET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENET_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("kon")],
     values: &[&["renekton"]],
     range: 3..=3,
 };
 
-static WORD_RENEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENEG_CHILDREN),
+static WORD_RENEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENEG_CHILDREN),
     value: None,
 };
 
-static WORD_RENEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENEG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEGA_NODE),
     None,
     None,
@@ -54899,12 +54899,12 @@ static WORD_RENEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENEGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENEGO_CHILDREN),
+static WORD_RENEGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENEGO_CHILDREN),
     value: None,
 };
 
-static WORD_RENEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENEGO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEGOA_NODE),
     None,
     Some(&WORD_RENEGOC_NODE),
@@ -54933,12 +54933,12 @@ static WORD_RENEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEGOZ_NODE),
 ];
 
-static WORD_RENEGOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOZ_CHILDREN),
+static WORD_RENEGOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -54964,12 +54964,12 @@ pub static WORD_RENEGOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_RENEGOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENEGOT_CHILDREN),
+static WORD_RENEGOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENEGOT_CHILDREN),
     value: None,
 };
 
-static WORD_RENEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENEGOT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEGOTA_NODE),
     None,
     None,
@@ -54998,12 +54998,12 @@ static WORD_RENEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENEGOTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENEGOTI_CHILDREN),
+static WORD_RENEGOTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENEGOTI_CHILDREN),
     value: None,
 };
 
-static WORD_RENEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENEGOTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_RENEGOTIB_NODE),
     Some(&WORD_RENEGOTIC_NODE),
@@ -55032,12 +55032,12 @@ static WORD_RENEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENEGOTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIT_CHILDREN),
+static WORD_RENEGOTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -55095,12 +55095,12 @@ pub static WORD_RENEGOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=6,
 };
 
-static WORD_RENEGOTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIO_CHILDREN),
+static WORD_RENEGOTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -55184,12 +55184,12 @@ pub static WORD_RENEGOTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=7,
 };
 
-static WORD_RENEGOTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIC_CHILDREN),
+static WORD_RENEGOTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -55215,23 +55215,23 @@ pub static WORD_RENEGOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 3..=6,
 };
 
-static WORD_RENEGOTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIB_CHILDREN),
+static WORD_RENEGOTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["renegotiable"]],
     range: 2..=2,
 };
 
-static WORD_RENEGOTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTH_CHILDREN),
+static WORD_RENEGOTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -55257,12 +55257,12 @@ pub static WORD_RENEGOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 4..=7,
 };
 
-static WORD_RENEGOTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTA_CHILDREN),
+static WORD_RENEGOTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -55354,12 +55354,12 @@ pub static WORD_RENEGOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=8,
 };
 
-static WORD_RENEGOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOS_CHILDREN),
+static WORD_RENEGOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -55385,12 +55385,12 @@ pub static WORD_RENEGOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_RENEGOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOP_CHILDREN),
+static WORD_RENEGOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tionsotiable"),
         dictgen::InsensitiveStr::Ascii("tionsotiate"),
@@ -55416,12 +55416,12 @@ pub static WORD_RENEGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 11..=14,
 };
 
-static WORD_RENEGOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOI_CHILDREN),
+static WORD_RENEGOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tate"),
@@ -55447,12 +55447,12 @@ pub static WORD_RENEGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_RENEGOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOG_CHILDREN),
+static WORD_RENEGOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tiable"),
         dictgen::InsensitiveStr::Ascii("tiate"),
@@ -55478,12 +55478,12 @@ pub static WORD_RENEGOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=8,
 };
 
-static WORD_RENEGOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOC_CHILDREN),
+static WORD_RENEGOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -55509,12 +55509,12 @@ pub static WORD_RENEGOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_RENEGOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOA_CHILDREN),
+static WORD_RENEGOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("te"),
@@ -55558,12 +55558,12 @@ pub static WORD_RENEGOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_RENEGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGE_CHILDREN),
+static WORD_RENEGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rate"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -55572,12 +55572,12 @@ pub static WORD_RENEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_RENEGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGA_CHILDREN),
+static WORD_RENEGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -55607,34 +55607,34 @@ pub static WORD_RENEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_RENED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENED_CHILDREN),
+static WORD_RENED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENED_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ered")],
     values: &[&["rende", "rendered"]],
     range: 4..=4,
 };
 
-static WORD_RENEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEA_CHILDREN),
+static WORD_RENEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gde")],
     values: &[&["renegade"]],
     range: 3..=3,
 };
 
-static WORD_REND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REND_CHILDREN),
+static WORD_REND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REND_CHILDREN),
     value: None,
 };
 
-pub static WORD_REND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayvoo"),
         dictgen::InsensitiveStr::Ascii("ayvooed"),
@@ -55708,12 +55708,12 @@ pub static WORD_REND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENA_CHILDREN),
+static WORD_RENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iisance"),
         dictgen::InsensitiveStr::Ascii("iscance"),
@@ -55737,12 +55737,12 @@ pub static WORD_RENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_REM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REM_CHILDREN),
+static WORD_REM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REM_CHILDREN),
     value: None,
 };
 
-static WORD_REM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REMA_NODE),
     Some(&WORD_REMB_NODE),
     None,
@@ -55771,12 +55771,12 @@ static WORD_REM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REMV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMV_CHILDREN),
+static WORD_REMV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMV_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -55804,34 +55804,34 @@ pub static WORD_REMV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_REMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMT_CHILDREN),
+static WORD_REMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oe")],
     values: &[&["remote"]],
     range: 2..=2,
 };
 
-static WORD_REMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMP_CHILDREN),
+static WORD_REMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lacement")],
     values: &[&["replacement"]],
     range: 8..=8,
 };
 
-static WORD_REMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMO_CHILDREN),
+static WORD_REMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -55877,23 +55877,23 @@ pub static WORD_REMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMN_CHILDREN),
+static WORD_REMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ans")],
     values: &[&["remnants"]],
     range: 3..=3,
 };
 
-static WORD_REMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMM_CHILDREN),
+static WORD_REMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apped"),
         dictgen::InsensitiveStr::Ascii("ber"),
@@ -55917,12 +55917,12 @@ pub static WORD_REMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMI_CHILDREN),
+static WORD_REMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("ander"),
@@ -56000,12 +56000,12 @@ pub static WORD_REMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_REME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REME_CHILDREN),
+static WORD_REME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REME_CHILDREN),
     value: None,
 };
 
-pub static WORD_REME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("bered"),
@@ -56095,12 +56095,12 @@ pub static WORD_REME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_REMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMB_CHILDREN),
+static WORD_REMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ember"),
         dictgen::InsensitiveStr::Ascii("embered"),
@@ -56118,12 +56118,12 @@ pub static WORD_REMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMA_CHILDREN),
+static WORD_REMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ind"),
         dictgen::InsensitiveStr::Ascii("inds"),
@@ -56191,12 +56191,12 @@ pub static WORD_REMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REL_CHILDREN),
+static WORD_REL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REL_CHILDREN),
     value: None,
 };
 
-static WORD_REL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RELA_NODE),
     None,
     Some(&WORD_RELC_NODE),
@@ -56225,12 +56225,12 @@ static WORD_REL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RELY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELY_CHILDREN),
+static WORD_RELY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ably"),
@@ -56248,23 +56248,23 @@ pub static WORD_RELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_RELV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELV_CHILDREN),
+static WORD_RELV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ant")],
     values: &[&["relevant"]],
     range: 3..=3,
 };
 
-static WORD_RELU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELU_CHILDREN),
+static WORD_RELU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctanct"),
         dictgen::InsensitiveStr::Ascii("ctanctly"),
@@ -56282,12 +56282,12 @@ pub static WORD_RELU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_RELT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELT_CHILDREN),
+static WORD_RELT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aionship"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -56296,12 +56296,12 @@ pub static WORD_RELT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RELP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELP_CHILDREN),
+static WORD_RELP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acement"),
         dictgen::InsensitiveStr::Ascii("ase"),
@@ -56312,12 +56312,12 @@ pub static WORD_RELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_RELO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELO_CHILDREN),
+static WORD_RELO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actes"),
         dictgen::InsensitiveStr::Ascii("ade"),
@@ -56369,23 +56369,23 @@ pub static WORD_RELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RELM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELM_CHILDREN),
+static WORD_RELM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELM_CHILDREN),
     value: Some(&["elm", "helm", "realm", "ream", "rem"]),
 };
 
-pub static WORD_RELM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["elms", "helms", "realms", "reams"]],
     range: 1..=1,
 };
 
-static WORD_RELL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELL_CHILDREN),
+static WORD_RELL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocates"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -56394,12 +56394,12 @@ pub static WORD_RELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RELI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELI_CHILDREN),
+static WORD_RELI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("abillity"),
@@ -56475,12 +56475,12 @@ pub static WORD_RELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_RELG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELG_CHILDREN),
+static WORD_RELG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ious"),
@@ -56489,12 +56489,12 @@ pub static WORD_RELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_RELF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELF_CHILDREN),
+static WORD_RELF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -56518,12 +56518,12 @@ pub static WORD_RELF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RELE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RELE_CHILDREN),
+static WORD_RELE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RELE_CHILDREN),
     value: None,
 };
 
-static WORD_RELE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RELE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RELEA_NODE),
     None,
     Some(&WORD_RELEC_NODE),
@@ -56552,23 +56552,23 @@ static WORD_RELE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RELEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEX_CHILDREN),
+static WORD_RELEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["relegation"]],
     range: 5..=5,
 };
 
-static WORD_RELEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEV_CHILDREN),
+static WORD_RELEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abt"),
         dictgen::InsensitiveStr::Ascii("ane"),
@@ -56596,12 +56596,12 @@ pub static WORD_RELEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RELET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELET_CHILDREN),
+static WORD_RELET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELET_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -56623,12 +56623,12 @@ pub static WORD_RELET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RELES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELES_CHILDREN),
+static WORD_RELES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELES_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -56648,23 +56648,23 @@ pub static WORD_RELES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_RELEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEO_CHILDREN),
+static WORD_RELEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ad")],
     values: &[&["reload"]],
     range: 2..=2,
 };
 
-static WORD_RELEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEN_CHILDREN),
+static WORD_RELEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tlesly"),
         dictgen::InsensitiveStr::Ascii("tlessely"),
@@ -56682,12 +56682,12 @@ pub static WORD_RELEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_RELEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEI_CHILDREN),
+static WORD_RELEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("fe"),
@@ -56715,12 +56715,12 @@ pub static WORD_RELEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_RELEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEG_CHILDREN),
+static WORD_RELEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ato"),
         dictgen::InsensitiveStr::Ascii("etion"),
@@ -56729,23 +56729,23 @@ pub static WORD_RELEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_RELEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEE_CHILDREN),
+static WORD_RELEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ction")],
     values: &[&["reelection"]],
     range: 5..=5,
 };
 
-static WORD_RELEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEC_CHILDREN),
+static WORD_RELEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -56761,12 +56761,12 @@ pub static WORD_RELEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_RELEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEA_CHILDREN),
+static WORD_RELEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -56838,12 +56838,12 @@ pub static WORD_RELEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_RELC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELC_CHILDREN),
+static WORD_RELC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aim"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -56859,12 +56859,12 @@ pub static WORD_RELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RELA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RELA_CHILDREN),
+static WORD_RELA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RELA_CHILDREN),
     value: Some(&["real"]),
 };
 
-static WORD_RELA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RELA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RELAA_NODE),
     None,
     Some(&WORD_RELAC_NODE),
@@ -56893,34 +56893,34 @@ static WORD_RELA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_RELAZ_NODE),
 ];
 
-static WORD_RELAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAZ_CHILDREN),
+static WORD_RELAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["relaxation"]],
     range: 5..=5,
 };
 
-static WORD_RELAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAX_CHILDREN),
+static WORD_RELAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ating")],
     values: &[&["relaxation"]],
     range: 5..=5,
 };
 
-static WORD_RELAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAV_CHILDREN),
+static WORD_RELAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -56936,12 +56936,12 @@ pub static WORD_RELAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_RELAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAT_CHILDREN),
+static WORD_RELAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("aive"),
@@ -57021,12 +57021,12 @@ pub static WORD_RELAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_RELAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAS_CHILDREN),
+static WORD_RELAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -57052,23 +57052,23 @@ pub static WORD_RELAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_RELAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAP_CHILDREN),
+static WORD_RELAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["relapse"]],
     range: 2..=2,
 };
 
-static WORD_RELAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAO_CHILDREN),
+static WORD_RELAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -57079,23 +57079,23 @@ pub static WORD_RELAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_RELAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAL_CHILDREN),
+static WORD_RELAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["really"]],
     range: 1..=1,
 };
 
-static WORD_RELAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAI_CHILDREN),
+static WORD_RELAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -57123,12 +57123,12 @@ pub static WORD_RELAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_RELAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAG_CHILDREN),
+static WORD_RELAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -57137,12 +57137,12 @@ pub static WORD_RELAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RELAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAE_CHILDREN),
+static WORD_RELAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -57160,23 +57160,23 @@ pub static WORD_RELAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_RELAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAD_CHILDREN),
+static WORD_RELAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["ready"]],
     range: 1..=1,
 };
 
-static WORD_RELAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAC_CHILDREN),
+static WORD_RELAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atable"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -57185,23 +57185,23 @@ pub static WORD_RELAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RELAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAA_CHILDREN),
+static WORD_RELAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tive")],
     values: &[&["relative"]],
     range: 4..=4,
 };
 
-static WORD_REK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REK_CHILDREN),
+static WORD_REK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REK_CHILDREN),
     value: None,
 };
 
-pub static WORD_REK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("enton"),
@@ -57227,12 +57227,12 @@ pub static WORD_REK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_REJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REJ_CHILDREN),
+static WORD_REJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cted"),
         dictgen::InsensitiveStr::Ascii("place"),
@@ -57241,12 +57241,12 @@ pub static WORD_REJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_REI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REI_CHILDREN),
+static WORD_REI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REI_CHILDREN),
     value: None,
 };
 
-static WORD_REI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_REIC_NODE),
@@ -57275,12 +57275,12 @@ static WORD_REI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIV_CHILDREN),
+static WORD_REIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ew"),
         dictgen::InsensitiveStr::Ascii("ews"),
@@ -57290,12 +57290,12 @@ pub static WORD_REIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_REIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIT_CHILDREN),
+static WORD_REIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rement"),
         dictgen::InsensitiveStr::Ascii("res"),
@@ -57313,12 +57313,12 @@ pub static WORD_REIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_REIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIS_CHILDREN),
+static WORD_REIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntall"),
         dictgen::InsensitiveStr::Ascii("ntalled"),
@@ -57336,12 +57336,12 @@ pub static WORD_REIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIP_CHILDREN),
+static WORD_REIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ient"),
         dictgen::InsensitiveStr::Ascii("ients"),
@@ -57350,12 +57350,12 @@ pub static WORD_REIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_REIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIN_CHILDREN),
+static WORD_REIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("assance"),
         dictgen::InsensitiveStr::Ascii("carantion"),
@@ -57459,12 +57459,12 @@ pub static WORD_REIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_REIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIM_CHILDREN),
+static WORD_REIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bursment"),
         dictgen::InsensitiveStr::Ascii("plemenet"),
@@ -57514,12 +57514,12 @@ pub static WORD_REIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=13,
 };
 
-static WORD_REIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIG_CHILDREN),
+static WORD_REIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ht"),
         dictgen::InsensitiveStr::Ascii("ining"),
@@ -57553,12 +57553,12 @@ pub static WORD_REIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIC_CHILDREN),
+static WORD_REIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arnation"),
         dictgen::InsensitiveStr::Ascii("eved"),
@@ -57567,12 +57567,12 @@ pub static WORD_REIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_REH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REH_CHILDREN),
+static WORD_REH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REH_CHILDREN),
     value: None,
 };
 
-pub static WORD_REH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abilitacion"),
         dictgen::InsensitiveStr::Ascii("abilitaion"),
@@ -57600,12 +57600,12 @@ pub static WORD_REH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_REG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REG_CHILDREN),
+static WORD_REG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REG_CHILDREN),
     value: None,
 };
 
-static WORD_REG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REGA_NODE),
     None,
     Some(&WORD_REGC_NODE),
@@ -57634,23 +57634,23 @@ static WORD_REG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REGY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGY_CHILDREN),
+static WORD_REGY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGY_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lar")],
     values: &[&["regular"]],
     range: 3..=3,
 };
 
-static WORD_REGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REGU_CHILDREN),
+static WORD_REGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REGU_CHILDREN),
     value: None,
 };
 
-static WORD_REGU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REGU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REGUA_NODE),
     None,
     None,
@@ -57679,23 +57679,23 @@ static WORD_REGU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REGUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUS_CHILDREN),
+static WORD_REGUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["register"]],
     range: 3..=3,
 };
 
-static WORD_REGUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUR_CHILDREN),
+static WORD_REGUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -57705,12 +57705,12 @@ pub static WORD_REGUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_REGUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUL_CHILDREN),
+static WORD_REGUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -57820,12 +57820,12 @@ pub static WORD_REGUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_REGUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUI_CHILDREN),
+static WORD_REGUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("re"),
         dictgen::InsensitiveStr::Ascii("red"),
@@ -57845,12 +57845,12 @@ pub static WORD_REGUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REGUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUA_CHILDREN),
+static WORD_REGUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lar"),
         dictgen::InsensitiveStr::Ascii("larly"),
@@ -57906,12 +57906,12 @@ pub static WORD_REGUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_REGS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGS_CHILDREN),
+static WORD_REGS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -57951,12 +57951,12 @@ pub static WORD_REGS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGR_CHILDREN),
+static WORD_REGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adless"),
         dictgen::InsensitiveStr::Ascii("ads"),
@@ -58006,12 +58006,12 @@ pub static WORD_REGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGO_CHILDREN),
+static WORD_REGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cnition"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -58029,23 +58029,23 @@ pub static WORD_REGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_REGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGL_CHILDREN),
+static WORD_REGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uar")],
     values: &[&["regular"]],
     range: 3..=3,
 };
 
-static WORD_REGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGI_CHILDREN),
+static WORD_REGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dstered"),
         dictgen::InsensitiveStr::Ascii("ems"),
@@ -58175,12 +58175,12 @@ pub static WORD_REGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_REGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGE_CHILDREN),
+static WORD_REGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ister"),
         dictgen::InsensitiveStr::Ascii("istered"),
@@ -58234,23 +58234,23 @@ pub static WORD_REGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_REGC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGC_CHILDREN),
+static WORD_REGC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onized")],
     values: &[&["recognized"]],
     range: 6..=6,
 };
 
-static WORD_REGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGA_CHILDREN),
+static WORD_REGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -58306,12 +58306,12 @@ pub static WORD_REGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_REF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REF_CHILDREN),
+static WORD_REF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REF_CHILDREN),
     value: None,
 };
 
-static WORD_REF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REFA_NODE),
     None,
     Some(&WORD_REFC_NODE),
@@ -58340,12 +58340,12 @@ static WORD_REF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFU_CHILDREN),
+static WORD_REFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("brished"),
         dictgen::InsensitiveStr::Ascii("dn"),
@@ -58367,12 +58367,12 @@ pub static WORD_REFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFR_CHILDREN),
+static WORD_REFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eh"),
         dictgen::InsensitiveStr::Ascii("ehser"),
@@ -58452,12 +58452,12 @@ pub static WORD_REFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_REFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFO_CHILDREN),
+static WORD_REFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cuss"),
         dictgen::InsensitiveStr::Ascii("cussed"),
@@ -58479,12 +58479,12 @@ pub static WORD_REFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_REFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFL_CHILDREN),
+static WORD_REFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eciton"),
         dictgen::InsensitiveStr::Ascii("ecte"),
@@ -58522,12 +58522,12 @@ pub static WORD_REFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFI_CHILDREN),
+static WORD_REFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ined"),
         dictgen::InsensitiveStr::Ascii("lles"),
@@ -58549,12 +58549,12 @@ pub static WORD_REFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_REFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFF_CHILDREN),
+static WORD_REFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("eral"),
@@ -58580,12 +58580,12 @@ pub static WORD_REFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_REFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REFE_CHILDREN),
+static WORD_REFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REFE_CHILDREN),
     value: None,
 };
 
-static WORD_REFE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REFE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_REFEC_NODE),
@@ -58614,12 +58614,12 @@ static WORD_REFE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REFES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFES_CHILDREN),
+static WORD_REFES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFES_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hed"),
@@ -58635,12 +58635,12 @@ pub static WORD_REFES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_REFER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REFER_CHILDREN),
+static WORD_REFER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REFER_CHILDREN),
     value: None,
 };
 
-static WORD_REFER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REFER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REFERA_NODE),
     None,
     None,
@@ -58669,23 +58669,23 @@ static WORD_REFER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REFERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERU_CHILDREN),
+static WORD_REFERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ndum")],
     values: &[&["referendum"]],
     range: 4..=4,
 };
 
-static WORD_REFERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERT_CHILDREN),
+static WORD_REFERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -58695,12 +58695,12 @@ pub static WORD_REFERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_REFERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERS_CHILDREN),
+static WORD_REFERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hed"),
         dictgen::InsensitiveStr::Ascii("her"),
@@ -58709,12 +58709,12 @@ pub static WORD_REFERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=3,
 };
 
-static WORD_REFERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERR_CHILDREN),
+static WORD_REFERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERR_CHILDREN),
     value: Some(&["refer"]),
 };
 
-pub static WORD_REFERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -58738,12 +58738,12 @@ pub static WORD_REFERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_REFERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERN_CHILDREN),
+static WORD_REFERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -58773,12 +58773,12 @@ pub static WORD_REFERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_REFERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERI_CHILDREN),
+static WORD_REFERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ang"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -58798,12 +58798,12 @@ pub static WORD_REFERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_REFERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERE_CHILDREN),
+static WORD_REFERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERE_CHILDREN),
     value: Some(&["refer", "referee"]),
 };
 
-pub static WORD_REFERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bces"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -58915,12 +58915,12 @@ pub static WORD_REFERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_REFERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERA_CHILDREN),
+static WORD_REFERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ls"),
@@ -58944,12 +58944,12 @@ pub static WORD_REFERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_REFEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEN_CHILDREN),
+static WORD_REFEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -58967,12 +58967,12 @@ pub static WORD_REFEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_REFEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEL_CHILDREN),
+static WORD_REFEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -58998,12 +58998,12 @@ pub static WORD_REFEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_REFEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEI_CHILDREN),
+static WORD_REFEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nement"),
         dictgen::InsensitiveStr::Ascii("nements"),
@@ -59012,34 +59012,34 @@ pub static WORD_REFEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_REFEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEE_CHILDREN),
+static WORD_REFEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("res")],
     values: &[&["referees"]],
     range: 3..=3,
 };
 
-static WORD_REFED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFED_CHILDREN),
+static WORD_REFED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFED_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("endum")],
     values: &[&["referendum"]],
     range: 5..=5,
 };
 
-static WORD_REFEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEC_CHILDREN),
+static WORD_REFEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -59061,12 +59061,12 @@ pub static WORD_REFEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_REFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFC_CHILDREN),
+static WORD_REFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ound"),
         dictgen::InsensitiveStr::Ascii("ounf"),
@@ -59075,12 +59075,12 @@ pub static WORD_REFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_REFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFA_CHILDREN),
+static WORD_REFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cor"),
         dictgen::InsensitiveStr::Ascii("rtor"),
@@ -59096,12 +59096,12 @@ pub static WORD_REFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_REE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REE_CHILDREN),
+static WORD_REE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -59187,12 +59187,12 @@ pub static WORD_REE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_RED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RED_CHILDREN),
+static WORD_RED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RED_CHILDREN),
     value: None,
 };
 
-static WORD_RED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RED_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REDA_NODE),
     None,
     Some(&WORD_REDC_NODE),
@@ -59221,23 +59221,23 @@ static WORD_RED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REDY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDY_CHILDREN),
+static WORD_REDY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDY_CHILDREN),
     value: Some(&["ready", "red"]),
 };
 
-pub static WORD_REDY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_REDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDU_CHILDREN),
+static WORD_REDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceable"),
         dictgen::InsensitiveStr::Ascii("dancy"),
@@ -59287,23 +59287,23 @@ pub static WORD_REDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDO_CHILDREN),
+static WORD_REDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nly")],
     values: &[&["readonly"]],
     range: 3..=3,
 };
 
-static WORD_REDN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDN_CHILDREN),
+static WORD_REDN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eckers"),
         dictgen::InsensitiveStr::Ascii("eckese"),
@@ -59321,34 +59321,34 @@ pub static WORD_REDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REDM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDM_CHILDREN),
+static WORD_REDM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDM_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eption")],
     values: &[&["redemption"]],
     range: 6..=6,
 };
 
-static WORD_REDL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDL_CHILDREN),
+static WORD_REDL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iens")],
     values: &[&["redlines"]],
     range: 4..=4,
 };
 
-static WORD_REDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDI_CHILDREN),
+static WORD_REDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cilous"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -59426,12 +59426,12 @@ pub static WORD_REDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_REDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDE_CHILDREN),
+static WORD_REDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("claation"),
@@ -59483,12 +59483,12 @@ pub static WORD_REDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDC_CHILDREN),
+static WORD_REDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("ue"),
@@ -59497,12 +59497,12 @@ pub static WORD_REDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_REDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDA_CHILDREN),
+static WORD_REDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -59518,12 +59518,12 @@ pub static WORD_REDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REC_CHILDREN),
+static WORD_REC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REC_CHILDREN),
     value: None,
 };
 
-static WORD_REC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RECA_NODE),
     None,
     Some(&WORD_RECC_NODE),
@@ -59552,12 +59552,12 @@ static WORD_REC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RECY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECY_CHILDREN),
+static WORD_RECY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clying"),
         dictgen::InsensitiveStr::Ascii("lcing"),
@@ -59577,23 +59577,23 @@ pub static WORD_RECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RECV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECV_CHILDREN),
+static WORD_RECV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ied")],
     values: &[&["received"]],
     range: 3..=3,
 };
 
-static WORD_RECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECU_CHILDREN),
+static WORD_RECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("iting"),
@@ -59683,12 +59683,12 @@ pub static WORD_RECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_RECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECT_CHILDREN),
+static WORD_RECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("angel"),
@@ -59724,12 +59724,12 @@ pub static WORD_RECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_RECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECR_CHILDREN),
+static WORD_RECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("ational"),
@@ -59817,23 +59817,23 @@ pub static WORD_RECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RECQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECQ_CHILDREN),
+static WORD_RECQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uired")],
     values: &[&["required"]],
     range: 5..=5,
 };
 
-static WORD_RECP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECP_CHILDREN),
+static WORD_RECP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etionist"),
         dictgen::InsensitiveStr::Ascii("etive"),
@@ -59851,12 +59851,12 @@ pub static WORD_RECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RECO_CHILDREN),
+static WORD_RECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RECO_CHILDREN),
     value: None,
 };
 
-static WORD_RECO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RECO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_RECOC_NODE),
@@ -59885,12 +59885,12 @@ static WORD_RECO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RECOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOV_CHILDREN),
+static WORD_RECOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("eres"),
@@ -59910,12 +59910,12 @@ pub static WORD_RECOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RECOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOU_CHILDREN),
+static WORD_RECOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rce"),
         dictgen::InsensitiveStr::Ascii("rced"),
@@ -59931,23 +59931,23 @@ pub static WORD_RECOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_RECOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOS_CHILDREN),
+static WORD_RECOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("truct")],
     values: &[&["reconstruct"]],
     range: 5..=5,
 };
 
-static WORD_RECOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOR_CHILDREN),
+static WORD_RECOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dare"),
         dictgen::InsensitiveStr::Ascii("darle"),
@@ -59977,12 +59977,12 @@ pub static WORD_RECOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RECON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RECON_CHILDREN),
+static WORD_RECON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RECON_CHILDREN),
     value: None,
 };
 
-static WORD_RECON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RECON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RECONA_NODE),
     None,
     Some(&WORD_RECONC_NODE),
@@ -60011,12 +60011,12 @@ static WORD_RECON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RECONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONT_CHILDREN),
+static WORD_RECONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ruct"),
         dictgen::InsensitiveStr::Ascii("ructed"),
@@ -60040,12 +60040,12 @@ pub static WORD_RECONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_RECONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONS_CHILDREN),
+static WORD_RECONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idder"),
         dictgen::InsensitiveStr::Ascii("iled"),
@@ -60083,12 +60083,12 @@ pub static WORD_RECONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_RECONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONN_CHILDREN),
+static WORD_RECONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aisance"),
         dictgen::InsensitiveStr::Ascii("aissence"),
@@ -60112,12 +60112,12 @@ pub static WORD_RECONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_RECONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONI_CHILDREN),
+static WORD_RECONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cle"),
         dictgen::InsensitiveStr::Ascii("sder"),
@@ -60135,12 +60135,12 @@ pub static WORD_RECONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_RECONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONG_CHILDREN),
+static WORD_RECONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifure"),
         dictgen::InsensitiveStr::Ascii("ise"),
@@ -60174,12 +60174,12 @@ pub static WORD_RECONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_RECONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONF_CHILDREN),
+static WORD_RECONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifure"),
         dictgen::InsensitiveStr::Ascii("iged"),
@@ -60199,12 +60199,12 @@ pub static WORD_RECONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_RECONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONE_CHILDREN),
+static WORD_RECONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cct"),
         dictgen::InsensitiveStr::Ascii("ccted"),
@@ -60272,23 +60272,23 @@ pub static WORD_RECONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_RECOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOND_CHILDREN),
+static WORD_RECOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ifure")],
     values: &[&["reconfigure"]],
     range: 5..=5,
 };
 
-static WORD_RECONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONC_CHILDREN),
+static WORD_RECONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ider"),
         dictgen::InsensitiveStr::Ascii("ilation"),
@@ -60306,12 +60306,12 @@ pub static WORD_RECONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_RECONA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONA_CHILDREN),
+static WORD_RECONA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("issance"),
         dictgen::InsensitiveStr::Ascii("sence"),
@@ -60320,12 +60320,12 @@ pub static WORD_RECONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=7,
 };
 
-static WORD_RECOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RECOM_CHILDREN),
+static WORD_RECOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RECOM_CHILDREN),
     value: None,
 };
 
-static WORD_RECOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RECOM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RECOMA_NODE),
     None,
     None,
@@ -60354,12 +60354,12 @@ static WORD_RECOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RECOMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOMP_CHILDREN),
+static WORD_RECOMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("lie"),
@@ -60383,12 +60383,12 @@ pub static WORD_RECOMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_RECOMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOMM_CHILDREN),
+static WORD_RECOMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -60494,23 +60494,23 @@ pub static WORD_RECOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_RECOMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOMI_CHILDREN),
+static WORD_RECOMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nant")],
     values: &[&["recombinant"]],
     range: 4..=4,
 };
 
-static WORD_RECOME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOME_CHILDREN),
+static WORD_RECOME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOME_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ndation"),
@@ -60534,34 +60534,34 @@ pub static WORD_RECOME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_RECOMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOMA_CHILDREN),
+static WORD_RECOMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nded")],
     values: &[&["recommended"]],
     range: 4..=4,
 };
 
-static WORD_RECOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOL_CHILDREN),
+static WORD_RECOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("leciton")],
     values: &[&["recollection"]],
     range: 7..=7,
 };
 
-static WORD_RECOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOG_CHILDREN),
+static WORD_RECOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inizer"),
         dictgen::InsensitiveStr::Ascii("inse"),
@@ -60613,34 +60613,34 @@ pub static WORD_RECOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RECOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOF_CHILDREN),
+static WORD_RECOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ig")],
     values: &[&["reconfig"]],
     range: 2..=2,
 };
 
-static WORD_RECOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOD_CHILDREN),
+static WORD_RECOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOD_CHILDREN),
     value: Some(&["record"]),
 };
 
-pub static WORD_RECOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_RECOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOC_CHILDREN),
+static WORD_RECOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("nisable"),
@@ -60654,12 +60654,12 @@ pub static WORD_RECOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_RECN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECN_CHILDREN),
+static WORD_RECN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tly"),
@@ -60668,12 +60668,12 @@ pub static WORD_RECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_RECL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECL_CHILDREN),
+static WORD_RECL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aimation"),
         dictgen::InsensitiveStr::Ascii("ami"),
@@ -60691,23 +60691,23 @@ pub static WORD_RECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RECK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECK_CHILDREN),
+static WORD_RECK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECK_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ognize")],
     values: &[&["recognize"]],
     range: 6..=6,
 };
 
-static WORD_RECJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECJ_CHILDREN),
+static WORD_RECJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -60718,12 +60718,12 @@ pub static WORD_RECJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_RECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECI_CHILDREN),
+static WORD_RECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -60831,12 +60831,12 @@ pub static WORD_RECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RECH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECH_CHILDREN),
+static WORD_RECH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECH_CHILDREN),
     value: Some(&["reach"]),
 };
 
-pub static WORD_RECH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("aged"),
@@ -60856,12 +60856,12 @@ pub static WORD_RECH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RECG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECG_CHILDREN),
+static WORD_RECG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onise"),
         dictgen::InsensitiveStr::Ascii("onised"),
@@ -60885,12 +60885,12 @@ pub static WORD_RECG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_RECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECE_CHILDREN),
+static WORD_RECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eded"),
         dictgen::InsensitiveStr::Ascii("eding"),
@@ -61014,12 +61014,12 @@ pub static WORD_RECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECC_CHILDREN),
+static WORD_RECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omend"),
         dictgen::InsensitiveStr::Ascii("omendation"),
@@ -61125,12 +61125,12 @@ pub static WORD_RECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_RECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECA_CHILDREN),
+static WORD_RECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hed"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -61184,12 +61184,12 @@ pub static WORD_RECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_REB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REB_CHILDREN),
+static WORD_REB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REB_CHILDREN),
     value: None,
 };
 
-pub static WORD_REB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ease"),
         dictgen::InsensitiveStr::Ascii("ellios"),
@@ -61263,12 +61263,12 @@ pub static WORD_REB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_REA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REA_CHILDREN),
+static WORD_REA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REA_CHILDREN),
     value: None,
 };
 
-static WORD_REA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REAA_NODE),
     None,
     Some(&WORD_REAC_NODE),
@@ -61297,23 +61297,23 @@ static WORD_REA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAY_CHILDREN),
+static WORD_REAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAY_CHILDREN),
     value: Some(&["ready", "really", "ray"]),
 };
 
-pub static WORD_REAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["ready", "read"]],
     range: 1..=1,
 };
 
-static WORD_REAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAV_CHILDREN),
+static WORD_REAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ealed"),
         dictgen::InsensitiveStr::Ascii("eled"),
@@ -61323,23 +61323,23 @@ pub static WORD_REAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_REAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAU_CHILDREN),
+static WORD_REAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ires")],
     values: &[&["requires"]],
     range: 4..=4,
 };
 
-static WORD_REAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAT_CHILDREN),
+static WORD_REAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -61363,12 +61363,12 @@ pub static WORD_REAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_REAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAS_CHILDREN),
+static WORD_REAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earch"),
         dictgen::InsensitiveStr::Ascii("earcher"),
@@ -61436,12 +61436,12 @@ pub static WORD_REAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAR_CHILDREN),
+static WORD_REAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angement"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -61537,23 +61537,23 @@ pub static WORD_REAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_REAQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAQ_CHILDREN),
+static WORD_REAQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uire")],
     values: &[&["reacquire", "require"]],
     range: 4..=4,
 };
 
-static WORD_REAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAP_CHILDREN),
+static WORD_REAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eat"),
         dictgen::InsensitiveStr::Ascii("eated"),
@@ -61591,12 +61591,12 @@ pub static WORD_REAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_REAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAO_CHILDREN),
+static WORD_REAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -61605,12 +61605,12 @@ pub static WORD_REAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_REAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAN_CHILDREN),
+static WORD_REAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("me"),
@@ -61628,12 +61628,12 @@ pub static WORD_REAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_REAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAM_CHILDREN),
+static WORD_REAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -61653,12 +61653,12 @@ pub static WORD_REAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_REAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REAL_CHILDREN),
+static WORD_REAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REAL_CHILDREN),
     value: None,
 };
 
-static WORD_REAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REALA_NODE),
     None,
     None,
@@ -61687,23 +61687,23 @@ static WORD_REAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALY_CHILDREN),
+static WORD_REALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALY_CHILDREN),
     value: Some(&["really", "relay", "real"]),
 };
 
-pub static WORD_REALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["really"]],
     range: 1..=1,
 };
 
-static WORD_REALT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALT_CHILDREN),
+static WORD_REALT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -61733,12 +61733,12 @@ pub static WORD_REALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALS_CHILDREN),
+static WORD_REALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -61756,12 +61756,12 @@ pub static WORD_REALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_REALO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALO_CHILDREN),
+static WORD_REALO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -61770,12 +61770,12 @@ pub static WORD_REALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALL_CHILDREN),
+static WORD_REALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALL_CHILDREN),
     value: Some(&["real", "really", "recall"]),
 };
 
-pub static WORD_REALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ize"),
@@ -61819,12 +61819,12 @@ pub static WORD_REALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_REALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALI_CHILDREN),
+static WORD_REALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("bility"),
@@ -61872,12 +61872,12 @@ pub static WORD_REALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALE_CHILDREN),
+static WORD_REALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -61887,12 +61887,12 @@ pub static WORD_REALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALA_CHILDREN),
+static WORD_REALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ted"),
         dictgen::InsensitiveStr::Ascii("tionship"),
@@ -61902,12 +61902,12 @@ pub static WORD_REALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAK_CHILDREN),
+static WORD_REAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("point"),
         dictgen::InsensitiveStr::Ascii("tivate"),
@@ -61917,23 +61917,23 @@ pub static WORD_REAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_REAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAI_CHILDREN),
+static WORD_REAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("se")],
     values: &[&["realise", "raise"]],
     range: 2..=2,
 };
 
-static WORD_REAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAG_CHILDREN),
+static WORD_REAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arding"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -61944,12 +61944,12 @@ pub static WORD_REAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAE_CHILDREN),
+static WORD_REAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ched"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -61958,12 +61958,12 @@ pub static WORD_REAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_READ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_READ_CHILDREN),
+static WORD_READ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_READ_CHILDREN),
     value: None,
 };
 
-pub static WORD_READ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_READ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abillity"),
         dictgen::InsensitiveStr::Ascii("abilty"),
@@ -62023,12 +62023,12 @@ pub static WORD_READ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAC_CHILDREN),
+static WORD_REAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahable"),
         dictgen::InsensitiveStr::Ascii("ahble"),
@@ -62070,12 +62070,12 @@ pub static WORD_REAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAA_CHILDREN),
+static WORD_REAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ly"),
         dictgen::InsensitiveStr::Ascii("range"),
@@ -62091,12 +62091,12 @@ pub static WORD_REAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RD_CHILDREN),
+static WORD_RD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RD_CHILDREN),
     value: None,
 };
 
-pub static WORD_RD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("uce"),
@@ -62105,12 +62105,12 @@ pub static WORD_RD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_RC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RC_CHILDREN),
+static WORD_RC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("eate"),
@@ -62120,12 +62120,12 @@ pub static WORD_RC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_RA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RA_CHILDREN),
+static WORD_RA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RA_CHILDREN),
     value: None,
 };
 
-static WORD_RA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_RAB_NODE),
     Some(&WORD_RAC_NODE),
@@ -62154,12 +62154,12 @@ static WORD_RA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAT_CHILDREN),
+static WORD_RAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atooee"),
         dictgen::InsensitiveStr::Ascii("atoolee"),
@@ -62199,12 +62199,12 @@ pub static WORD_RAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_RAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAS_CHILDREN),
+static WORD_RAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("berry"),
         dictgen::InsensitiveStr::Ascii("bperries"),
@@ -62238,12 +62238,12 @@ pub static WORD_RAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_RAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAR_CHILDREN),
+static WORD_RAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elly"),
         dictgen::InsensitiveStr::Ascii("ified"),
@@ -62252,23 +62252,23 @@ pub static WORD_RAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_RAQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAQ_CHILDREN),
+static WORD_RAQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uetball")],
     values: &[&["racquetball"]],
     range: 7..=7,
 };
 
-static WORD_RAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAP_CHILDREN),
+static WORD_RAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("air"),
         dictgen::InsensitiveStr::Ascii("ell"),
@@ -62320,12 +62320,12 @@ pub static WORD_RAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_RAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAO_CHILDREN),
+static WORD_RAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ches"),
         dictgen::InsensitiveStr::Ascii("ming"),
@@ -62355,12 +62355,12 @@ pub static WORD_RAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_RAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAN_CHILDREN),
+static WORD_RAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dam"),
         dictgen::InsensitiveStr::Ascii("dayvoo"),
@@ -62418,12 +62418,12 @@ pub static WORD_RAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_RAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAM_CHILDREN),
+static WORD_RAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ains"),
         dictgen::InsensitiveStr::Ascii("domly"),
@@ -62433,12 +62433,12 @@ pub static WORD_RAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_RAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAL_CHILDREN),
+static WORD_RAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -62447,12 +62447,12 @@ pub static WORD_RAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_RAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAI_CHILDREN),
+static WORD_RAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dance"),
         dictgen::InsensitiveStr::Ascii("dant"),
@@ -62478,12 +62478,12 @@ pub static WORD_RAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_RAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAH_CHILDREN),
+static WORD_RAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("psody"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -62492,12 +62492,12 @@ pub static WORD_RAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_RAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAE_CHILDREN),
+static WORD_RAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -62517,12 +62517,12 @@ pub static WORD_RAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_RAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAD_CHILDREN),
+static WORD_RAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aince"),
         dictgen::InsensitiveStr::Ascii("aint"),
@@ -62592,12 +62592,12 @@ pub static WORD_RAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_RAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAC_CHILDREN),
+static WORD_RAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aus"),
         dictgen::InsensitiveStr::Ascii("hives"),
@@ -62625,12 +62625,12 @@ pub static WORD_RAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_RAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAB_CHILDREN),
+static WORD_RAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bitos"),
         dictgen::InsensitiveStr::Ascii("bitts"),
@@ -62648,12 +62648,12 @@ pub static WORD_RAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_Q_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_Q_CHILDREN),
+static WORD_Q_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_Q_CHILDREN),
     value: None,
 };
 
-static WORD_Q_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_Q_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_QA_NODE),
     None,
     None,
@@ -62682,12 +62682,12 @@ static WORD_Q_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_QW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QW_CHILDREN),
+static WORD_QW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QW_CHILDREN),
     value: None,
 };
 
-pub static WORD_QW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esant"),
         dictgen::InsensitiveStr::Ascii("esants"),
@@ -62703,12 +62703,12 @@ pub static WORD_QW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_QU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_QU_CHILDREN),
+static WORD_QU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_QU_CHILDREN),
     value: None,
 };
 
-static WORD_QU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_QU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_QUA_NODE),
     Some(&WORD_QUB_NODE),
     Some(&WORD_QUC_NODE),
@@ -62737,12 +62737,12 @@ static WORD_QU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_QUW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUW_CHILDREN),
+static WORD_QUW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUW_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esant"),
         dictgen::InsensitiveStr::Ascii("esants"),
@@ -62758,34 +62758,34 @@ pub static WORD_QUW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_QUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUU_CHILDREN),
+static WORD_QUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ery")],
     values: &[&["query"]],
     range: 3..=3,
 };
 
-static WORD_QUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUT_CHILDREN),
+static WORD_QUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ie")],
     values: &[&["quite", "quiet"]],
     range: 2..=2,
 };
 
-static WORD_QUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUS_CHILDREN),
+static WORD_QUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -62796,12 +62796,12 @@ pub static WORD_QUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_QUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUR_CHILDREN),
+static WORD_QUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ey"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -62821,12 +62821,12 @@ pub static WORD_QUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_QUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUO_CHILDREN),
+static WORD_QUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("shant"),
         dictgen::InsensitiveStr::Ascii("shants"),
@@ -62848,12 +62848,12 @@ pub static WORD_QUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_QUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUN_CHILDREN),
+static WORD_QUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atum"),
         dictgen::InsensitiveStr::Ascii("etin"),
@@ -62862,12 +62862,12 @@ pub static WORD_QUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_QUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUL_CHILDREN),
+static WORD_QUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aity"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -62876,12 +62876,12 @@ pub static WORD_QUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_QUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUI_CHILDREN),
+static WORD_QUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bic"),
         dictgen::InsensitiveStr::Ascii("cket"),
@@ -62943,12 +62943,12 @@ pub static WORD_QUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_QUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_QUE_CHILDREN),
+static WORD_QUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_QUE_CHILDREN),
     value: None,
 };
 
-static WORD_QUE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_QUE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_QUEA_NODE),
     None,
     None,
@@ -62977,23 +62977,23 @@ static WORD_QUE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_QUEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEW_CHILDREN),
+static WORD_QUEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEW_CHILDREN),
     value: Some(&["queue"]),
 };
 
-pub static WORD_QUEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_QUEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEU_CHILDREN),
+static WORD_QUEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEU_CHILDREN),
     value: Some(&["queue"]),
 };
 
-pub static WORD_QUEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("eud"),
@@ -63003,12 +63003,12 @@ pub static WORD_QUEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_QUET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUET_CHILDREN),
+static WORD_QUET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUET_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -63018,12 +63018,12 @@ pub static WORD_QUET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_QUES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUES_CHILDREN),
+static WORD_QUES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUES_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -63111,12 +63111,12 @@ pub static WORD_QUES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_QUER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUER_CHILDREN),
+static WORD_QUER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUER_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eis"),
@@ -63144,23 +63144,23 @@ pub static WORD_QUER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_QUEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEN_CHILDREN),
+static WORD_QUEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["quentin"]],
     range: 4..=4,
 };
 
-static WORD_QUEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEI_CHILDREN),
+static WORD_QUEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("res"),
@@ -63178,12 +63178,12 @@ pub static WORD_QUEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_QUEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEE_CHILDREN),
+static WORD_QUEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEE_CHILDREN),
     value: Some(&["queue"]),
 };
 
-pub static WORD_QUEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nland"),
         dictgen::InsensitiveStr::Ascii("ue"),
@@ -63192,12 +63192,12 @@ pub static WORD_QUEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_QUEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEA_CHILDREN),
+static WORD_QUEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tions"),
@@ -63206,23 +63206,23 @@ pub static WORD_QUEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_QUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUD_CHILDREN),
+static WORD_QUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rangles")],
     values: &[&["quadrangles"]],
     range: 7..=7,
 };
 
-static WORD_QUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUC_CHILDREN),
+static WORD_QUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ik"),
         dictgen::InsensitiveStr::Ascii("ikest"),
@@ -63232,23 +63232,23 @@ pub static WORD_QUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_QUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUB_CHILDREN),
+static WORD_QUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ic")],
     values: &[&["cubic", "qubit"]],
     range: 2..=2,
 };
 
-static WORD_QUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_QUA_CHILDREN),
+static WORD_QUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_QUA_CHILDREN),
     value: None,
 };
 
-static WORD_QUA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_QUA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -63277,12 +63277,12 @@ static WORD_QUA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_QUAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAT_CHILDREN),
+static WORD_QUAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -63312,12 +63312,12 @@ pub static WORD_QUAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_QUAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAR_CHILDREN),
+static WORD_QUAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antaine"),
         dictgen::InsensitiveStr::Ascii("ante"),
@@ -63367,12 +63367,12 @@ pub static WORD_QUAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_QUAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAN_CHILDREN),
+static WORD_QUAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itfy"),
         dictgen::InsensitiveStr::Ascii("ities"),
@@ -63440,12 +63440,12 @@ pub static WORD_QUAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_QUAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAL_CHILDREN),
+static WORD_QUAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fied"),
         dictgen::InsensitiveStr::Ascii("fiiers"),
@@ -63507,12 +63507,12 @@ pub static WORD_QUAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_QUAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAI_CHILDREN),
+static WORD_QUAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfiers"),
         dictgen::InsensitiveStr::Ascii("lfy"),
@@ -63530,12 +63530,12 @@ pub static WORD_QUAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_QUAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAF_CHILDREN),
+static WORD_QUAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eur"),
         dictgen::InsensitiveStr::Ascii("eured"),
@@ -63544,12 +63544,12 @@ pub static WORD_QUAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_QUAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAD_CHILDREN),
+static WORD_QUAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ddec"),
         dictgen::InsensitiveStr::Ascii("ranle"),
@@ -63579,23 +63579,23 @@ pub static WORD_QUAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_QT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QT_CHILDREN),
+static WORD_QT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QT_CHILDREN),
     value: None,
 };
 
-pub static WORD_QT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uie")],
     values: &[&["quite", "quiet"]],
     range: 3..=3,
 };
 
-static WORD_QO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QO_CHILDREN),
+static WORD_QO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QO_CHILDREN),
     value: None,
 };
 
-pub static WORD_QO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uoted"),
         dictgen::InsensitiveStr::Ascii("utation"),
@@ -63617,12 +63617,12 @@ pub static WORD_QO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_QI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QI_CHILDREN),
+static WORD_QI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QI_CHILDREN),
     value: None,
 };
 
-pub static WORD_QI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ests"),
@@ -63632,23 +63632,23 @@ pub static WORD_QI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_QH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QH_CHILDREN),
+static WORD_QH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QH_CHILDREN),
     value: None,
 };
 
-pub static WORD_QH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ich")],
     values: &[&["quiche", "which"]],
     range: 3..=3,
 };
 
-static WORD_QE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QE_CHILDREN),
+static WORD_QE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QE_CHILDREN),
     value: None,
 };
 
-pub static WORD_QE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("st"),
         dictgen::InsensitiveStr::Ascii("stions"),
@@ -63674,12 +63674,12 @@ pub static WORD_QE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_QA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QA_CHILDREN),
+static WORD_QA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QA_CHILDREN),
     value: None,
 };
 
-pub static WORD_QA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ulification"),
         dictgen::InsensitiveStr::Ascii("ulifications"),
@@ -63705,12 +63705,12 @@ pub static WORD_QA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=12,
 };
 
-static WORD_P_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_P_CHILDREN),
+static WORD_P_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_P_CHILDREN),
     value: None,
 };
 
-static WORD_P_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_P_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PA_NODE),
     Some(&WORD_PB_NODE),
     None,
@@ -63739,12 +63739,12 @@ static WORD_P_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PY_CHILDREN),
+static WORD_PY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("armid"),
         dictgen::InsensitiveStr::Ascii("hon"),
@@ -63844,12 +63844,12 @@ pub static WORD_PY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_PX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PX_CHILDREN),
+static WORD_PX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oxied"),
         dictgen::InsensitiveStr::Ascii("oxies"),
@@ -63859,23 +63859,23 @@ pub static WORD_PX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_PW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PW_CHILDREN),
+static WORD_PW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oer")],
     values: &[&["power"]],
     range: 3..=3,
 };
 
-static WORD_PU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PU_CHILDREN),
+static WORD_PU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PU_CHILDREN),
     value: None,
 };
 
-static WORD_PU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PUA_NODE),
     Some(&WORD_PUB_NODE),
     Some(&WORD_PUC_NODE),
@@ -63904,12 +63904,12 @@ static WORD_PU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUT_CHILDREN),
+static WORD_PUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("pose"),
@@ -63920,12 +63920,12 @@ pub static WORD_PUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_PUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUS_CHILDREN),
+static WORD_PUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blishing"),
         dictgen::InsensitiveStr::Ascii("ehd"),
@@ -63936,12 +63936,12 @@ pub static WORD_PUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_PUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUR_CHILDREN),
+static WORD_PUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agtory"),
         dictgen::InsensitiveStr::Ascii("cahed"),
@@ -64033,12 +64033,12 @@ pub static WORD_PUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_PUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUP_CHILDREN),
+static WORD_PUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lar"),
         dictgen::InsensitiveStr::Ascii("larity"),
@@ -64072,12 +64072,12 @@ pub static WORD_PUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_PUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUN_CHILDREN),
+static WORD_PUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctation"),
         dictgen::InsensitiveStr::Ascii("ctiation"),
@@ -64127,12 +64127,12 @@ pub static WORD_PUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_PUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUM_CHILDREN),
+static WORD_PUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kin"),
         dictgen::InsensitiveStr::Ascii("kpins"),
@@ -64143,12 +64143,12 @@ pub static WORD_PUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_PUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUL_CHILDREN),
+static WORD_PUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("isher"),
@@ -64158,45 +64158,45 @@ pub static WORD_PUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_PUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUI_CHILDREN),
+static WORD_PUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nsher")],
     values: &[&["punisher"]],
     range: 5..=5,
 };
 
-static WORD_PUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUH_CHILDREN),
+static WORD_PUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sups")],
     values: &[&["pushups"]],
     range: 4..=4,
 };
 
-static WORD_PUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUE_CHILDREN),
+static WORD_PUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sdo")],
     values: &[&["pseudo"]],
     range: 3..=3,
 };
 
-static WORD_PUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUC_CHILDREN),
+static WORD_PUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hase"),
@@ -64214,12 +64214,12 @@ pub static WORD_PUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_PUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PUB_CHILDREN),
+static WORD_PUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PUB_CHILDREN),
     value: None,
 };
 
-static WORD_PUB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PUB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -64248,12 +64248,12 @@ static WORD_PUB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PUBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUBL_CHILDREN),
+static WORD_PUBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cation"),
@@ -64379,12 +64379,12 @@ pub static WORD_PUBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PUBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUBI_CHILDREN),
+static WORD_PUBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lc"),
         dictgen::InsensitiveStr::Ascii("lsh"),
@@ -64414,23 +64414,23 @@ pub static WORD_PUBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUA_CHILDREN),
+static WORD_PUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sing")],
     values: &[&["pausing"]],
     range: 4..=4,
 };
 
-static WORD_PT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PT_CHILDREN),
+static WORD_PT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("herad"),
@@ -64470,12 +64470,12 @@ pub static WORD_PT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_PS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PS_CHILDREN),
+static WORD_PS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PS_CHILDREN),
     value: None,
 };
 
-static WORD_PS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PSA_NODE),
     None,
     Some(&WORD_PSC_NODE),
@@ -64504,12 +64504,12 @@ static WORD_PS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSY_CHILDREN),
+static WORD_PSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chadelic"),
         dictgen::InsensitiveStr::Ascii("chaitric"),
@@ -64627,12 +64627,12 @@ pub static WORD_PSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_PSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSU_CHILDREN),
+static WORD_PSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deo"),
         dictgen::InsensitiveStr::Ascii("do"),
@@ -64676,12 +64676,12 @@ pub static WORD_PSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_PSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSS_CHILDREN),
+static WORD_PSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ibility"),
@@ -64690,23 +64690,23 @@ pub static WORD_PSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_PSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSR_CHILDREN),
+static WORD_PSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ameter")],
     values: &[&["parameter"]],
     range: 6..=6,
 };
 
-static WORD_PSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSO_CHILDREN),
+static WORD_PSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -64716,12 +64716,12 @@ pub static WORD_PSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_PSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSI_CHILDREN),
+static WORD_PSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chological"),
         dictgen::InsensitiveStr::Ascii("chologically"),
@@ -64741,12 +64741,12 @@ pub static WORD_PSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_PSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSH_CHILDREN),
+static WORD_PSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("yciatric"),
         dictgen::InsensitiveStr::Ascii("yciatrist"),
@@ -64778,12 +64778,12 @@ pub static WORD_PSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=12,
 };
 
-static WORD_PSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSE_CHILDREN),
+static WORD_PSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deo"),
         dictgen::InsensitiveStr::Ascii("duo"),
@@ -64807,12 +64807,12 @@ pub static WORD_PSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_PSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSC_CHILDREN),
+static WORD_PSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("yhed"),
         dictgen::InsensitiveStr::Ascii("yhedelic"),
@@ -64846,12 +64846,12 @@ pub static WORD_PSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_PSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSA_CHILDREN),
+static WORD_PSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -64869,12 +64869,12 @@ pub static WORD_PSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_PR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PR_CHILDREN),
+static WORD_PR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PR_CHILDREN),
     value: None,
 };
 
-static WORD_PR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRA_NODE),
     Some(&WORD_PRB_NODE),
     Some(&WORD_PRC_NODE),
@@ -64903,12 +64903,12 @@ static WORD_PR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRY_CHILDREN),
+static WORD_PRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amid"),
         dictgen::InsensitiveStr::Ascii("amids"),
@@ -64917,12 +64917,12 @@ pub static WORD_PRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_PRV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRV_CHILDREN),
+static WORD_PRV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("ide"),
@@ -64942,12 +64942,12 @@ pub static WORD_PRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_PRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRU_CHILDREN),
+static WORD_PRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chase"),
         dictgen::InsensitiveStr::Ascii("chased"),
@@ -64975,23 +64975,23 @@ pub static WORD_PRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRT_CHILDREN),
+static WORD_PRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inf")],
     values: &[&["printf"]],
     range: 3..=3,
 };
 
-static WORD_PRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRS_CHILDREN),
+static WORD_PRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -65000,12 +65000,12 @@ pub static WORD_PRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_PRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRR_CHILDREN),
+static WORD_PRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cision"),
         dictgen::InsensitiveStr::Ascii("ottypes"),
@@ -65014,12 +65014,12 @@ pub static WORD_PRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_PRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRP_CHILDREN),
+static WORD_PRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eparations"),
         dictgen::InsensitiveStr::Ascii("ose"),
@@ -65041,12 +65041,12 @@ pub static WORD_PRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_PRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRO_CHILDREN),
+static WORD_PRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRO_CHILDREN),
     value: None,
 };
 
-static WORD_PRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROA_NODE),
     Some(&WORD_PROB_NODE),
     Some(&WORD_PROC_NODE),
@@ -65075,23 +65075,23 @@ static WORD_PRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROZ_NODE),
 ];
 
-static WORD_PROZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROZ_CHILDREN),
+static WORD_PROZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["process"]],
     range: 3..=3,
 };
 
-static WORD_PROY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROY_CHILDREN),
+static WORD_PROY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -65111,12 +65111,12 @@ pub static WORD_PROY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PROX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROX_CHILDREN),
+static WORD_PROX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imty"),
         dictgen::InsensitiveStr::Ascii("yed"),
@@ -65125,12 +65125,12 @@ pub static WORD_PROX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PROV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROV_CHILDREN),
+static WORD_PROV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROV_CHILDREN),
     value: None,
 };
 
-static WORD_PROV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROVA_NODE),
     None,
     None,
@@ -65159,23 +65159,23 @@ static WORD_PROV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVS_CHILDREN),
+static WORD_PROVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ioning")],
     values: &[&["provisioning"]],
     range: 6..=6,
 };
 
-static WORD_PROVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVO_CHILDREN),
+static WORD_PROVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("active"),
         dictgen::InsensitiveStr::Ascii("catie"),
@@ -65209,12 +65209,12 @@ pub static WORD_PROVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVI_CHILDREN),
+static WORD_PROVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cative"),
         dictgen::InsensitiveStr::Ascii("cde"),
@@ -65324,12 +65324,12 @@ pub static WORD_PROVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PROVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVE_CHILDREN),
+static WORD_PROVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dd"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -65353,12 +65353,12 @@ pub static WORD_PROVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PROVD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVD_CHILDREN),
+static WORD_PROVD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -65386,12 +65386,12 @@ pub static WORD_PROVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_PROVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVA_CHILDREN),
+static WORD_PROVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cative"),
         dictgen::InsensitiveStr::Ascii("cotive"),
@@ -65401,12 +65401,12 @@ pub static WORD_PROVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROU_CHILDREN),
+static WORD_PROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ldy"),
         dictgen::InsensitiveStr::Ascii("ncements"),
@@ -65415,12 +65415,12 @@ pub static WORD_PROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PROT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROT_CHILDREN),
+static WORD_PROT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROT_CHILDREN),
     value: None,
 };
 
-static WORD_PROT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROTA_NODE),
     None,
     Some(&WORD_PROTC_NODE),
@@ -65449,23 +65449,23 @@ static WORD_PROT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROTY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTY_CHILDREN),
+static WORD_PROTY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pted")],
     values: &[&["prototyped"]],
     range: 4..=4,
 };
 
-static WORD_PROTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTU_CHILDREN),
+static WORD_PROTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gal"),
         dictgen::InsensitiveStr::Ascii("guese"),
@@ -65474,12 +65474,12 @@ pub static WORD_PROTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_PROTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTR_CHILDREN),
+static WORD_PROTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ait"),
         dictgen::InsensitiveStr::Ascii("aits"),
@@ -65505,12 +65505,12 @@ pub static WORD_PROTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PROTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTO_CHILDREN),
+static WORD_PROTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("call"),
@@ -65594,12 +65594,12 @@ pub static WORD_PROTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PROTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTL_CHILDREN),
+static WORD_PROTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -65608,12 +65608,12 @@ pub static WORD_PROTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PROTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTI_CHILDREN),
+static WORD_PROTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -65633,34 +65633,34 @@ pub static WORD_PROTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTH_CHILDREN),
+static WORD_PROTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("setic")],
     values: &[&["prosthetic"]],
     range: 5..=5,
 };
 
-static WORD_PROTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTF_CHILDREN),
+static WORD_PROTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olio")],
     values: &[&["portfolio"]],
     range: 4..=4,
 };
 
-static WORD_PROTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTE_CHILDREN),
+static WORD_PROTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -65750,12 +65750,12 @@ pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTC_CHILDREN),
+static WORD_PROTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ol"),
         dictgen::InsensitiveStr::Ascii("ols"),
@@ -65773,12 +65773,12 @@ pub static WORD_PROTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PROTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTA_CHILDREN),
+static WORD_PROTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -65818,12 +65818,12 @@ pub static WORD_PROTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROS_CHILDREN),
+static WORD_PROS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cratination"),
         dictgen::InsensitiveStr::Ascii("ectued"),
@@ -65955,12 +65955,12 @@ pub static WORD_PROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PROR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROR_CHILDREN),
+static WORD_PROR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ities"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -65970,12 +65970,12 @@ pub static WORD_PROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_PROP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROP_CHILDREN),
+static WORD_PROP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROP_CHILDREN),
     value: None,
 };
 
-static WORD_PROP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROPA_NODE),
     Some(&WORD_PROPB_NODE),
     None,
@@ -66004,23 +66004,23 @@ static WORD_PROP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROPV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPV_CHILDREN),
+static WORD_PROPV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ider")],
     values: &[&["provider"]],
     range: 4..=4,
 };
 
-static WORD_PROPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPU_CHILDREN),
+static WORD_PROPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laios"),
         dictgen::InsensitiveStr::Ascii("lsing"),
@@ -66038,12 +66038,12 @@ pub static WORD_PROPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PROPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPT_CHILDREN),
+static WORD_PROPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPT_CHILDREN),
     value: Some(&["prompt"]),
 };
 
-pub static WORD_PROPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eries"),
         dictgen::InsensitiveStr::Ascii("erties"),
@@ -66059,12 +66059,12 @@ pub static WORD_PROPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPS_CHILDREN),
+static WORD_PROPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -66088,12 +66088,12 @@ pub static WORD_PROPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_PROPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPR_CHILDREN),
+static WORD_PROPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eitary"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -66167,12 +66167,12 @@ pub static WORD_PROPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PROPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPP_CHILDREN),
+static WORD_PROPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ely"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -66190,12 +66190,12 @@ pub static WORD_PROPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPO_CHILDREN),
+static WORD_PROPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agate"),
         dictgen::InsensitiveStr::Ascii("erties"),
@@ -66297,12 +66297,12 @@ pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PROPM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPM_CHILDREN),
+static WORD_PROPM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -66322,12 +66322,12 @@ pub static WORD_PROPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_PROPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPL_CHILDREN),
+static WORD_PROPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("em"),
         dictgen::InsensitiveStr::Ascii("usion"),
@@ -66336,12 +66336,12 @@ pub static WORD_PROPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PROPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPI_CHILDREN),
+static WORD_PROPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ertary"),
         dictgen::InsensitiveStr::Ascii("etary"),
@@ -66363,12 +66363,12 @@ pub static WORD_PROPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PROPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPH_CHILDREN),
+static WORD_PROPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acies"),
         dictgen::InsensitiveStr::Ascii("acy"),
@@ -66390,12 +66390,12 @@ pub static WORD_PROPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROPG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPG_CHILDREN),
+static WORD_PROPG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("ating"),
@@ -66404,12 +66404,12 @@ pub static WORD_PROPG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PROPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROPE_CHILDREN),
+static WORD_PROPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROPE_CHILDREN),
     value: None,
 };
 
-static WORD_PROPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_PROPEC_NODE),
@@ -66438,12 +66438,12 @@ static WORD_PROPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPET_CHILDREN),
+static WORD_PROPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("iies"),
@@ -66463,23 +66463,23 @@ pub static WORD_PROPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_PROPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPES_CHILDREN),
+static WORD_PROPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("terous")],
     values: &[&["preposterous"]],
     range: 6..=6,
 };
 
-static WORD_PROPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPER_CHILDREN),
+static WORD_PROPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eties"),
         dictgen::InsensitiveStr::Ascii("ety"),
@@ -66559,23 +66559,23 @@ pub static WORD_PROPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PROPEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEO_CHILDREN),
+static WORD_PROPEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("perties")],
     values: &[&["properties"]],
     range: 7..=7,
 };
 
-static WORD_PROPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEN_CHILDREN),
+static WORD_PROPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("city"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -66584,23 +66584,23 @@ pub static WORD_PROPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=4,
 };
 
-static WORD_PROPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEL_CHILDREN),
+static WORD_PROPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["properly"]],
     range: 1..=1,
 };
 
-static WORD_PROPEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEH_CHILDREN),
+static WORD_PROPEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cy"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -66610,23 +66610,23 @@ pub static WORD_PROPEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_PROPEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEG_CHILDREN),
+static WORD_PROPEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ate")],
     values: &[&["propagate"]],
     range: 3..=3,
 };
 
-static WORD_PROPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEC_CHILDREN),
+static WORD_PROPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hies"),
         dictgen::InsensitiveStr::Ascii("hy"),
@@ -66662,23 +66662,23 @@ pub static WORD_PROPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PROPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPB_CHILDREN),
+static WORD_PROPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ably")],
     values: &[&["probably"]],
     range: 4..=4,
 };
 
-static WORD_PROPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPA_CHILDREN),
+static WORD_PROPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilities"),
         dictgen::InsensitiveStr::Ascii("bly"),
@@ -66712,12 +66712,12 @@ pub static WORD_PROPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROO_CHILDREN),
+static WORD_PROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cecure"),
         dictgen::InsensitiveStr::Ascii("cecures"),
@@ -66791,12 +66791,12 @@ pub static WORD_PROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PRON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRON_CHILDREN),
+static WORD_PRON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRON_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nounced"),
         dictgen::InsensitiveStr::Ascii("ography"),
@@ -66854,12 +66854,12 @@ pub static WORD_PRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PROM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROM_CHILDREN),
+static WORD_PROM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROM_CHILDREN),
     value: None,
 };
 
-static WORD_PROM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROMA_NODE),
     None,
     None,
@@ -66888,12 +66888,12 @@ static WORD_PROM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMT_CHILDREN),
+static WORD_PROMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMT_CHILDREN),
     value: Some(&["prompt"]),
 };
 
-pub static WORD_PROMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -66921,23 +66921,23 @@ pub static WORD_PROMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_PROMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMS_CHILDREN),
+static WORD_PROMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icuous")],
     values: &[&["promiscuous"]],
     range: 6..=6,
 };
 
-static WORD_PROMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMP_CHILDREN),
+static WORD_PROMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lty"),
         dictgen::InsensitiveStr::Ascii("rted"),
@@ -66957,12 +66957,12 @@ pub static WORD_PROMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_PROMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMO_CHILDREN),
+static WORD_PROMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cional"),
         dictgen::InsensitiveStr::Ascii("rdials"),
@@ -66990,12 +66990,12 @@ pub static WORD_PROMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PROMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMM_CHILDREN),
+static WORD_PROMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pts"),
@@ -67004,12 +67004,12 @@ pub static WORD_PROMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PROMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMI_CHILDREN),
+static WORD_PROMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mently"),
         dictgen::InsensitiveStr::Ascii("nance"),
@@ -67061,12 +67061,12 @@ pub static WORD_PROMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PROME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROME_CHILDREN),
+static WORD_PROME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROME_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nantly"),
         dictgen::InsensitiveStr::Ascii("nently"),
@@ -67096,23 +67096,23 @@ pub static WORD_PROME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PROMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMA_CHILDREN),
+static WORD_PROMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tory")],
     values: &[&["promontory"]],
     range: 4..=4,
 };
 
-static WORD_PROL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROL_CHILDREN),
+static WORD_PROL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ateriat"),
         dictgen::InsensitiveStr::Ascii("bems"),
@@ -67154,23 +67154,23 @@ pub static WORD_PROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROK_CHILDREN),
+static WORD_PROK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROK_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rastination")],
     values: &[&["procrastination"]],
     range: 11..=11,
 };
 
-static WORD_PROJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROJ_CHILDREN),
+static WORD_PROJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cet"),
         dictgen::InsensitiveStr::Ascii("cets"),
@@ -67256,12 +67256,12 @@ pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROI_CHILDREN),
+static WORD_PROI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("fle"),
@@ -67281,12 +67281,12 @@ pub static WORD_PROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PROH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROH_CHILDREN),
+static WORD_PROH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abition"),
         dictgen::InsensitiveStr::Ascii("ibation"),
@@ -67350,12 +67350,12 @@ pub static WORD_PROH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PROG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROG_CHILDREN),
+static WORD_PROG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROG_CHILDREN),
     value: None,
 };
 
-static WORD_PROG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROGA_NODE),
     None,
     None,
@@ -67384,12 +67384,12 @@ static WORD_PROG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROGR_CHILDREN),
+static WORD_PROGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROGR_CHILDREN),
     value: None,
 };
 
-static WORD_PROGR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROGR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROGRA_NODE),
     None,
     None,
@@ -67418,23 +67418,23 @@ static WORD_PROGR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROGRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRS_CHILDREN),
+static WORD_PROGRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["progress"]],
     range: 1..=1,
 };
 
-static WORD_PROGRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRO_CHILDREN),
+static WORD_PROGRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("ms"),
@@ -67443,12 +67443,12 @@ pub static WORD_PROGRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_PROGRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRM_CHILDREN),
+static WORD_PROGRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -67458,12 +67458,12 @@ pub static WORD_PROGRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_PROGRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRE_CHILDREN),
+static WORD_PROGRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -67549,12 +67549,12 @@ pub static WORD_PROGRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_PROGRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRA_CHILDREN),
+static WORD_PROGRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aming"),
         dictgen::InsensitiveStr::Ascii("ma"),
@@ -67630,23 +67630,23 @@ pub static WORD_PROGRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_PROGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGI_CHILDREN),
+static WORD_PROGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dy")],
     values: &[&["prodigy"]],
     range: 2..=2,
 };
 
-static WORD_PROGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGE_CHILDREN),
+static WORD_PROGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rssion"),
         dictgen::InsensitiveStr::Ascii("rssive"),
@@ -67674,12 +67674,12 @@ pub static WORD_PROGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROGA_CHILDREN),
+static WORD_PROGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROGA_CHILDREN),
     value: None,
 };
 
-static WORD_PROGA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROGA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -67708,12 +67708,12 @@ static WORD_PROGA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROGAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAT_CHILDREN),
+static WORD_PROGAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ators"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -67737,12 +67737,12 @@ pub static WORD_PROGAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PROGAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAR_CHILDREN),
+static WORD_PROGAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amm"),
         dictgen::InsensitiveStr::Ascii("ammability"),
@@ -67790,12 +67790,12 @@ pub static WORD_PROGAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_PROGAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAP_CHILDREN),
+static WORD_PROGAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -67819,12 +67819,12 @@ pub static WORD_PROGAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PROGAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAM_CHILDREN),
+static WORD_PROGAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAM_CHILDREN),
     value: Some(&["program"]),
 };
 
-pub static WORD_PROGAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -67870,12 +67870,12 @@ pub static WORD_PROGAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_PROGAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAG_CHILDREN),
+static WORD_PROGAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -67899,12 +67899,12 @@ pub static WORD_PROGAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PROF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROF_CHILDREN),
+static WORD_PROF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROF_CHILDREN),
     value: None,
 };
 
-static WORD_PROF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -67933,12 +67933,12 @@ static WORD_PROF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFU_CHILDREN),
+static WORD_PROFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ndly"),
@@ -67947,34 +67947,34 @@ pub static WORD_PROFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PROFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFT_CHILDREN),
+static WORD_PROFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iable")],
     values: &[&["profitable"]],
     range: 5..=5,
 };
 
-static WORD_PROFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFR_CHILDREN),
+static WORD_PROFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("essions")],
     values: &[&["progressions"]],
     range: 7..=7,
 };
 
-static WORD_PROFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFL_CHILDREN),
+static WORD_PROFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -67992,12 +67992,12 @@ pub static WORD_PROFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PROFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFI_CHILDREN),
+static WORD_PROFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceint"),
         dictgen::InsensitiveStr::Ascii("ciancy"),
@@ -68065,12 +68065,12 @@ pub static WORD_PROFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PROFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFF_CHILDREN),
+static WORD_PROFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esed"),
         dictgen::InsensitiveStr::Ascii("esion"),
@@ -68094,12 +68094,12 @@ pub static WORD_PROFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_PROFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFE_CHILDREN),
+static WORD_PROFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sion"),
         dictgen::InsensitiveStr::Ascii("sional"),
@@ -68175,12 +68175,12 @@ pub static WORD_PROFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PROE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROE_CHILDREN),
+static WORD_PROE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cess"),
         dictgen::InsensitiveStr::Ascii("ceudre"),
@@ -68222,12 +68222,12 @@ pub static WORD_PROE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROD_CHILDREN),
+static WORD_PROD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceding"),
         dictgen::InsensitiveStr::Ascii("cut"),
@@ -68335,12 +68335,12 @@ pub static WORD_PROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROC_CHILDREN),
+static WORD_PROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROC_CHILDREN),
     value: None,
 };
 
-static WORD_PROC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROCA_NODE),
     None,
     Some(&WORD_PROCC_NODE),
@@ -68369,12 +68369,12 @@ static WORD_PROC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCU_CHILDREN),
+static WORD_PROCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -68408,12 +68408,12 @@ pub static WORD_PROCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PROCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCT_CHILDREN),
+static WORD_PROCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -68431,23 +68431,23 @@ pub static WORD_PROCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PROCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCS_CHILDREN),
+static WORD_PROCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sed")],
     values: &[&["processed"]],
     range: 3..=3,
 };
 
-static WORD_PROCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCR_CHILDREN),
+static WORD_PROCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ascinating"),
         dictgen::InsensitiveStr::Ascii("astenating"),
@@ -68495,12 +68495,12 @@ pub static WORD_PROCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_PROCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCO_CHILDREN),
+static WORD_PROCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("essed"),
@@ -68520,12 +68520,12 @@ pub static WORD_PROCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PROCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCL_CHILDREN),
+static WORD_PROCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aimation"),
         dictgen::InsensitiveStr::Ascii("am"),
@@ -68551,12 +68551,12 @@ pub static WORD_PROCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCI_CHILDREN),
+static WORD_PROCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -68566,12 +68566,12 @@ pub static WORD_PROCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PROCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROCE_CHILDREN),
+static WORD_PROCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROCE_CHILDREN),
     value: Some(&["price"]),
 };
 
-static WORD_PROCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROCE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_PROCEC_NODE),
@@ -68600,12 +68600,12 @@ static WORD_PROCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROCES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCES_CHILDREN),
+static WORD_PROCES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCES_CHILDREN),
     value: Some(&["process"]),
 };
 
-pub static WORD_PROCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -68681,23 +68681,23 @@ pub static WORD_PROCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_PROCEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCEN_CHILDREN),
+static WORD_PROCEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tual")],
     values: &[&["percentual"]],
     range: 4..=4,
 };
 
-static WORD_PROCEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCEL_CHILDREN),
+static WORD_PROCEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ains"),
@@ -68706,12 +68706,12 @@ pub static WORD_PROCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_PROCEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCEE_CHILDREN),
+static WORD_PROCEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deds"),
         dictgen::InsensitiveStr::Ascii("des"),
@@ -68747,12 +68747,12 @@ pub static WORD_PROCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PROCED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCED_CHILDREN),
+static WORD_PROCED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCED_CHILDREN),
     value: Some(&["proceed"]),
 };
 
-pub static WORD_PROCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("dings"),
@@ -68794,12 +68794,12 @@ pub static WORD_PROCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_PROCEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCEC_CHILDREN),
+static WORD_PROCEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("ure"),
@@ -68809,12 +68809,12 @@ pub static WORD_PROCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_PROCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCC_CHILDREN),
+static WORD_PROCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eding"),
         dictgen::InsensitiveStr::Ascii("edings"),
@@ -68852,12 +68852,12 @@ pub static WORD_PROCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCA_CHILDREN),
+static WORD_PROCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lim"),
         dictgen::InsensitiveStr::Ascii("limed"),
@@ -68875,12 +68875,12 @@ pub static WORD_PROCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROB_CHILDREN),
+static WORD_PROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROB_CHILDREN),
     value: None,
 };
 
-static WORD_PROB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROBA_NODE),
     Some(&WORD_PROBB_NODE),
     None,
@@ -68909,23 +68909,23 @@ static WORD_PROB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBO_CHILDREN),
+static WORD_PROBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bly")],
     values: &[&["probably"]],
     range: 3..=3,
 };
 
-static WORD_PROBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBL_CHILDREN),
+static WORD_PROBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("aem"),
@@ -68967,23 +68967,23 @@ pub static WORD_PROBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PROBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBI_CHILDREN),
+static WORD_PROBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lity")],
     values: &[&["probability"]],
     range: 4..=4,
 };
 
-static WORD_PROBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBE_CHILDREN),
+static WORD_PROBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lm"),
         dictgen::InsensitiveStr::Ascii("lmatic"),
@@ -69003,12 +69003,12 @@ pub static WORD_PROBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_PROBB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBB_CHILDREN),
+static WORD_PROBB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("ailities"),
@@ -69036,12 +69036,12 @@ pub static WORD_PROBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBA_CHILDREN),
+static WORD_PROBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bably"),
         dictgen::InsensitiveStr::Ascii("balistic"),
@@ -69113,12 +69113,12 @@ pub static WORD_PROBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_PROA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROA_CHILDREN),
+static WORD_PROA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bably"),
         dictgen::InsensitiveStr::Ascii("baly"),
@@ -69140,12 +69140,12 @@ pub static WORD_PROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRM_CHILDREN),
+static WORD_PRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itive"),
         dictgen::InsensitiveStr::Ascii("itives"),
@@ -69155,12 +69155,12 @@ pub static WORD_PRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_PRJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRJ_CHILDREN),
+static WORD_PRJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ecting"),
@@ -69178,12 +69178,12 @@ pub static WORD_PRJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRI_CHILDREN),
+static WORD_PRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRI_CHILDREN),
     value: None,
 };
 
-static WORD_PRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRIA_NODE),
     None,
     Some(&WORD_PRIC_NODE),
@@ -69212,12 +69212,12 @@ static WORD_PRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRIV_CHILDREN),
+static WORD_PRIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRIV_CHILDREN),
     value: None,
 };
 
-static WORD_PRIV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRIV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRIVA_NODE),
     None,
     Some(&WORD_PRIVC_NODE),
@@ -69246,34 +69246,34 @@ static WORD_PRIV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRIVT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVT_CHILDREN),
+static WORD_PRIVT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["private"]],
     range: 1..=1,
 };
 
-static WORD_PRIVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVO_CHILDREN),
+static WORD_PRIVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ded")],
     values: &[&["provided"]],
     range: 3..=3,
 };
 
-static WORD_PRIVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVL_CHILDREN),
+static WORD_PRIVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edge"),
         dictgen::InsensitiveStr::Ascii("ege"),
@@ -69289,12 +69289,12 @@ pub static WORD_PRIVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PRIVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVI_CHILDREN),
+static WORD_PRIVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -69374,12 +69374,12 @@ pub static WORD_PRIVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PRIVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVE_CHILDREN),
+static WORD_PRIVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laged"),
         dictgen::InsensitiveStr::Ascii("lages"),
@@ -69417,34 +69417,34 @@ pub static WORD_PRIVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PRIVD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVD_CHILDREN),
+static WORD_PRIVD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["provide"]],
     range: 1..=1,
 };
 
-static WORD_PRIVC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVC_CHILDREN),
+static WORD_PRIVC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["privacy"]],
     range: 1..=1,
 };
 
-static WORD_PRIVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVA_CHILDREN),
+static WORD_PRIVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ledge"),
         dictgen::InsensitiveStr::Ascii("lege"),
@@ -69466,23 +69466,23 @@ pub static WORD_PRIVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PRIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIT_CHILDREN),
+static WORD_PRIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["printing"]],
     range: 3..=3,
 };
 
-static WORD_PRIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIS_CHILDREN),
+static WORD_PRIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIS_CHILDREN),
     value: Some(&["prise", "prism"]),
 };
 
-pub static WORD_PRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("itne"),
@@ -69492,12 +69492,12 @@ pub static WORD_PRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PRIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIR_CHILDREN),
+static WORD_PRIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ity"),
         dictgen::InsensitiveStr::Ascii("oity"),
@@ -69513,12 +69513,12 @@ pub static WORD_PRIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PRIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIP_CHILDREN),
+static WORD_PRIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heral"),
         dictgen::InsensitiveStr::Ascii("oritzes"),
@@ -69527,12 +69527,12 @@ pub static WORD_PRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PRIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIO_CHILDREN),
+static WORD_PRIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irties"),
         dictgen::InsensitiveStr::Ascii("irty"),
@@ -69604,12 +69604,12 @@ pub static WORD_PRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PRIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIN_CHILDREN),
+static WORD_PRIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cepals"),
         dictgen::InsensitiveStr::Ascii("ceple"),
@@ -69691,12 +69691,12 @@ pub static WORD_PRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PRIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIM_CHILDREN),
+static WORD_PRIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aires"),
         dictgen::InsensitiveStr::Ascii("airly"),
@@ -69760,12 +69760,12 @@ pub static WORD_PRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PRIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIE_CHILDREN),
+static WORD_PRIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mere"),
         dictgen::InsensitiveStr::Ascii("stes"),
@@ -69781,12 +69781,12 @@ pub static WORD_PRIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PRIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIC_CHILDREN),
+static WORD_PRIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inpals"),
         dictgen::InsensitiveStr::Ascii("ipal"),
@@ -69804,12 +69804,12 @@ pub static WORD_PRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PRIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIA_CHILDREN),
+static WORD_PRIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sed"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -69819,23 +69819,23 @@ pub static WORD_PRIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRG_CHILDREN),
+static WORD_PRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ram")],
     values: &[&["program"]],
     range: 3..=3,
 };
 
-static WORD_PRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRF_CHILDREN),
+static WORD_PRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erable"),
@@ -69853,12 +69853,12 @@ pub static WORD_PRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_PRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRE_CHILDREN),
+static WORD_PRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRE_CHILDREN),
     value: None,
 };
 
-static WORD_PRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREA_NODE),
     Some(&WORD_PREB_NODE),
     Some(&WORD_PREC_NODE),
@@ -69887,23 +69887,23 @@ static WORD_PRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREZ_NODE),
 ];
 
-static WORD_PREZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREZ_CHILDREN),
+static WORD_PREZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("idential")],
     values: &[&["presidential"]],
     range: 8..=8,
 };
 
-static WORD_PREX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREX_CHILDREN),
+static WORD_PREX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isting"),
         dictgen::InsensitiveStr::Ascii("ixed"),
@@ -69912,23 +69912,23 @@ pub static WORD_PREX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PREW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREW_CHILDREN),
+static WORD_PREW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("view")],
     values: &[&["preview"]],
     range: 4..=4,
 };
 
-static WORD_PREV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PREV_CHILDREN),
+static WORD_PREV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PREV_CHILDREN),
     value: None,
 };
 
-static WORD_PREV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PREV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREVA_NODE),
     None,
     None,
@@ -69957,12 +69957,12 @@ static WORD_PREV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PREVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREVO_CHILDREN),
+static WORD_PREVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ius"),
         dictgen::InsensitiveStr::Ascii("iusly"),
@@ -69980,12 +69980,12 @@ pub static WORD_PREVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PREVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREVI_CHILDREN),
+static WORD_PREVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aling"),
@@ -70049,12 +70049,12 @@ pub static WORD_PREVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PREVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREVE_CHILDREN),
+static WORD_PREVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iw"),
         dictgen::InsensitiveStr::Ascii("iwed"),
@@ -70118,12 +70118,12 @@ pub static WORD_PREVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PREVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREVA_CHILDREN),
+static WORD_PREVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilaing"),
         dictgen::InsensitiveStr::Ascii("illing"),
@@ -70141,12 +70141,12 @@ pub static WORD_PREVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRET_CHILDREN),
+static WORD_PRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRET_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ador"),
         dictgen::InsensitiveStr::Ascii("aining"),
@@ -70204,12 +70204,12 @@ pub static WORD_PRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRES_CHILDREN),
+static WORD_PRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRES_CHILDREN),
     value: None,
 };
 
-static WORD_PRES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRESA_NODE),
     Some(&WORD_PRESB_NODE),
     Some(&WORD_PRESC_NODE),
@@ -70238,12 +70238,12 @@ static WORD_PRES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRESU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESU_CHILDREN),
+static WORD_PRESU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -70293,12 +70293,12 @@ pub static WORD_PRESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PREST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREST_CHILDREN),
+static WORD_PREST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREST_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egious"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -70334,12 +70334,12 @@ pub static WORD_PREST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PRESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESS_CHILDREN),
+static WORD_PRESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -70375,12 +70375,12 @@ pub static WORD_PRESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PRESR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESR_CHILDREN),
+static WORD_PRESR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciption"),
         dictgen::InsensitiveStr::Ascii("eved"),
@@ -70390,12 +70390,12 @@ pub static WORD_PRESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PRESP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESP_CHILDREN),
+static WORD_PRESP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ective"),
         dictgen::InsensitiveStr::Ascii("ectives"),
@@ -70404,12 +70404,12 @@ pub static WORD_PRESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_PRESO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESO_CHILDREN),
+static WORD_PRESO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mption"),
         dictgen::InsensitiveStr::Ascii("nalized"),
@@ -70427,12 +70427,12 @@ pub static WORD_PRESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PRESN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESN_CHILDREN),
+static WORD_PRESN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etation"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -70448,12 +70448,12 @@ pub static WORD_PRESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PRESM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESM_CHILDREN),
+static WORD_PRESM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("issions"),
         dictgen::InsensitiveStr::Ascii("uably"),
@@ -70462,12 +70462,12 @@ pub static WORD_PRESM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PRESI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESI_CHILDREN),
+static WORD_PRESI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cely"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -70539,12 +70539,12 @@ pub static WORD_PRESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PRESH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESH_CHILDREN),
+static WORD_PRESH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("is"),
         dictgen::InsensitiveStr::Ascii("isly"),
@@ -70560,12 +70560,12 @@ pub static WORD_PRESH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PRESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESE_CHILDREN),
+static WORD_PRESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aring"),
         dictgen::InsensitiveStr::Ascii("arvation"),
@@ -70689,12 +70689,12 @@ pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PRESC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESC_CHILDREN),
+static WORD_PRESC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edence"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -70744,12 +70744,12 @@ pub static WORD_PRESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PRESB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESB_CHILDREN),
+static WORD_PRESB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aterian"),
         dictgen::InsensitiveStr::Ascii("aterians"),
@@ -70765,23 +70765,23 @@ pub static WORD_PRESB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_PRESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESA_CHILDREN),
+static WORD_PRESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nce")],
     values: &[&["presence"]],
     range: 3..=3,
 };
 
-static WORD_PRER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRER_CHILDREN),
+static WORD_PRER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRER_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("equesit"),
         dictgen::InsensitiveStr::Ascii("equesite"),
@@ -70827,12 +70827,12 @@ pub static WORD_PRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PREQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREQ_CHILDREN),
+static WORD_PREQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euls"),
         dictgen::InsensitiveStr::Ascii("uisite"),
@@ -70848,12 +70848,12 @@ pub static WORD_PREQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREP_CHILDREN),
+static WORD_PREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("air"),
         dictgen::InsensitiveStr::Ascii("aird"),
@@ -70987,12 +70987,12 @@ pub static WORD_PREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_PREO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREO_CHILDREN),
+static WORD_PREO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cess"),
         dictgen::InsensitiveStr::Ascii("cessing"),
@@ -71026,12 +71026,12 @@ pub static WORD_PREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_PREM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREM_CHILDREN),
+static WORD_PREM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anent"),
         dictgen::InsensitiveStr::Ascii("anently"),
@@ -71103,12 +71103,12 @@ pub static WORD_PREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_PREL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREL_CHILDREN),
+static WORD_PREL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayed"),
         dictgen::InsensitiveStr::Ascii("ease"),
@@ -71134,12 +71134,12 @@ pub static WORD_PREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_PREJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREJ_CHILDREN),
+static WORD_PREJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -71189,12 +71189,12 @@ pub static WORD_PREJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PREI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREI_CHILDREN),
+static WORD_PREI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dction"),
         dictgen::InsensitiveStr::Ascii("mer"),
@@ -71246,23 +71246,23 @@ pub static WORD_PREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_PREH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREH_CHILDREN),
+static WORD_PREH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aps")],
     values: &[&["perhaps"]],
     range: 3..=3,
 };
 
-static WORD_PREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREG_CHILDREN),
+static WORD_PREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancies"),
         dictgen::InsensitiveStr::Ascii("ancy"),
@@ -71288,12 +71288,12 @@ pub static WORD_PREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PREF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PREF_CHILDREN),
+static WORD_PREF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PREF_CHILDREN),
     value: None,
 };
 
-static WORD_PREF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PREF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREFA_NODE),
     None,
     None,
@@ -71322,12 +71322,12 @@ static WORD_PREF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PREFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFR_CHILDREN),
+static WORD_PREFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ences"),
@@ -71336,12 +71336,12 @@ pub static WORD_PREFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PREFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFO_CHILDREN),
+static WORD_PREFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rmance"),
         dictgen::InsensitiveStr::Ascii("rmances"),
@@ -71359,12 +71359,12 @@ pub static WORD_PREFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PREFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFI_CHILDREN),
+static WORD_PREFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ces"),
         dictgen::InsensitiveStr::Ascii("ciency"),
@@ -71392,12 +71392,12 @@ pub static WORD_PREFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PREFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFF_CHILDREN),
+static WORD_PREFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erable"),
@@ -71421,12 +71421,12 @@ pub static WORD_PREFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PREFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFE_CHILDREN),
+static WORD_PREFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctches"),
         dictgen::InsensitiveStr::Ascii("cth"),
@@ -71548,12 +71548,12 @@ pub static WORD_PREFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_PREFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFA_CHILDREN),
+static WORD_PREFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rable"),
         dictgen::InsensitiveStr::Ascii("rably"),
@@ -71562,12 +71562,12 @@ pub static WORD_PREFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_PREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREE_CHILDREN),
+static WORD_PREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceding"),
         dictgen::InsensitiveStr::Ascii("mptable"),
@@ -71587,12 +71587,12 @@ pub static WORD_PREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PRED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRED_CHILDREN),
+static WORD_PRED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRED_CHILDREN),
     value: None,
 };
 
-static WORD_PRED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRED_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREDA_NODE),
     None,
     None,
@@ -71621,12 +71621,12 @@ static WORD_PRED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PREDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDU_CHILDREN),
+static WORD_PREDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -71644,12 +71644,12 @@ pub static WORD_PREDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PREDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDO_CHILDREN),
+static WORD_PREDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessor"),
         dictgen::InsensitiveStr::Ascii("cessors"),
@@ -71675,12 +71675,12 @@ pub static WORD_PREDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_PREDJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDJ_CHILDREN),
+static WORD_PREDJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uice"),
         dictgen::InsensitiveStr::Ascii("uiced"),
@@ -71690,12 +71690,12 @@ pub static WORD_PREDJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PREDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDI_CHILDREN),
+static WORD_PREDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cat"),
         dictgen::InsensitiveStr::Ascii("catble"),
@@ -71763,23 +71763,23 @@ pub static WORD_PREDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PREDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDF_CHILDREN),
+static WORD_PREDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ined")],
     values: &[&["predefined"]],
     range: 4..=4,
 };
 
-static WORD_PREDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDE_CHILDREN),
+static WORD_PREDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cated"),
         dictgen::InsensitiveStr::Ascii("ccesors"),
@@ -71845,12 +71845,12 @@ pub static WORD_PREDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_PREDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDA_CHILDREN),
+static WORD_PREDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessor"),
         dictgen::InsensitiveStr::Ascii("cessors"),
@@ -71860,12 +71860,12 @@ pub static WORD_PREDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PREC_CHILDREN),
+static WORD_PREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PREC_CHILDREN),
     value: None,
 };
 
-static WORD_PREC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PREC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRECA_NODE),
     None,
     Some(&WORD_PRECC_NODE),
@@ -71894,12 +71894,12 @@ static WORD_PREC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECU_CHILDREN),
+static WORD_PRECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -71929,12 +71929,12 @@ pub static WORD_PRECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PRECS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECS_CHILDREN),
+static WORD_PRECS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -71943,23 +71943,23 @@ pub static WORD_PRECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PRECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECR_CHILDREN),
+static WORD_PRECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("astination")],
     values: &[&["procrastination"]],
     range: 10..=10,
 };
 
-static WORD_PRECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECO_CHILDREN),
+static WORD_PRECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("miled"),
         dictgen::InsensitiveStr::Ascii("mupte"),
@@ -72005,12 +72005,12 @@ pub static WORD_PRECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_PRECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECI_CHILDREN),
+static WORD_PRECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -72052,12 +72052,12 @@ pub static WORD_PRECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PRECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECE_CHILDREN),
+static WORD_PRECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessor"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -72145,34 +72145,34 @@ pub static WORD_PRECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PRECD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECD_CHILDREN),
+static WORD_PRECD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["preceding"]],
     range: 3..=3,
 };
 
-static WORD_PRECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECC_CHILDREN),
+static WORD_PRECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eding")],
     values: &[&["preceding"]],
     range: 5..=5,
 };
 
-static WORD_PRECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECA_CHILDREN),
+static WORD_PRECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cheed"),
         dictgen::InsensitiveStr::Ascii("lulated"),
@@ -72192,23 +72192,23 @@ pub static WORD_PRECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PREB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREB_CHILDREN),
+static WORD_PREB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ious")],
     values: &[&["previous"]],
     range: 4..=4,
 };
 
-static WORD_PREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREA_CHILDREN),
+static WORD_PREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dtor"),
         dictgen::InsensitiveStr::Ascii("dtors"),
@@ -72246,12 +72246,12 @@ pub static WORD_PREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PRD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRD_CHILDREN),
+static WORD_PRD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pagate"),
         dictgen::InsensitiveStr::Ascii("pagated"),
@@ -72275,12 +72275,12 @@ pub static WORD_PRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_PRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRC_CHILDREN),
+static WORD_PRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edure"),
         dictgen::InsensitiveStr::Ascii("eeded"),
@@ -72310,23 +72310,23 @@ pub static WORD_PRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRB_CHILDREN),
+static WORD_PRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lem")],
     values: &[&["problem"]],
     range: 3..=3,
 };
 
-static WORD_PRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRA_CHILDREN),
+static WORD_PRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRA_CHILDREN),
     value: None,
 };
 
-static WORD_PRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRAA_NODE),
     Some(&WORD_PRAB_NODE),
     Some(&WORD_PRAC_NODE),
@@ -72355,12 +72355,12 @@ static WORD_PRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAY_CHILDREN),
+static WORD_PRAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ries"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -72370,12 +72370,12 @@ pub static WORD_PRAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAT_CHILDREN),
+static WORD_PRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cise"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -72399,12 +72399,12 @@ pub static WORD_PRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PRAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAS_CHILDREN),
+static WORD_PRAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -72414,12 +72414,12 @@ pub static WORD_PRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PRAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAR_CHILDREN),
+static WORD_PRAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ameter"),
         dictgen::InsensitiveStr::Ascii("ameters"),
@@ -72430,12 +72430,12 @@ pub static WORD_PRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAM_CHILDREN),
+static WORD_PRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ater"),
         dictgen::InsensitiveStr::Ascii("eter"),
@@ -72445,12 +72445,12 @@ pub static WORD_PRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAI_CHILDREN),
+static WORD_PRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ry"),
         dictgen::InsensitiveStr::Ascii("sse"),
@@ -72459,12 +72459,12 @@ pub static WORD_PRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAG_CHILDREN),
+static WORD_PRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("amtic"),
@@ -72474,23 +72474,23 @@ pub static WORD_PRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAE_CHILDREN),
+static WORD_PRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fix")],
     values: &[&["prefix"]],
     range: 3..=3,
 };
 
-static WORD_PRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAC_CHILDREN),
+static WORD_PRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itcal"),
         dictgen::InsensitiveStr::Ascii("itcally"),
@@ -72568,12 +72568,12 @@ pub static WORD_PRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_PRAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAB_CHILDREN),
+static WORD_PRAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -72583,12 +72583,12 @@ pub static WORD_PRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PRAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAA_CHILDREN),
+static WORD_PRAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meter"),
         dictgen::InsensitiveStr::Ascii("meters"),
@@ -72597,12 +72597,12 @@ pub static WORD_PRAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PP_CHILDREN),
+static WORD_PP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("check"),
         dictgen::InsensitiveStr::Ascii("eline"),
@@ -72626,12 +72626,12 @@ pub static WORD_PP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_PO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PO_CHILDREN),
+static WORD_PO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PO_CHILDREN),
     value: None,
 };
 
-static WORD_PO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_POB_NODE),
     Some(&WORD_POC_NODE),
@@ -72660,12 +72660,12 @@ static WORD_PO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_POZ_NODE),
 ];
 
-static WORD_POZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POZ_CHILDREN),
+static WORD_POZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_POZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itive"),
         dictgen::InsensitiveStr::Ascii("itively"),
@@ -72675,12 +72675,12 @@ pub static WORD_POZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_POY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POY_CHILDREN),
+static WORD_POY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POY_CHILDREN),
     value: None,
 };
 
-pub static WORD_POY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lgon"),
         dictgen::InsensitiveStr::Ascii("lmer"),
@@ -72689,12 +72689,12 @@ pub static WORD_POY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_POW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POW_CHILDREN),
+static WORD_POW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POW_CHILDREN),
     value: None,
 };
 
-pub static WORD_POW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("derade"),
         dictgen::InsensitiveStr::Ascii("derd"),
@@ -72750,12 +72750,12 @@ pub static WORD_POW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_POV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POV_CHILDREN),
+static WORD_POV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POV_CHILDREN),
     value: None,
 };
 
-pub static WORD_POV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erful"),
         dictgen::InsensitiveStr::Ascii("ided"),
@@ -72764,12 +72764,12 @@ pub static WORD_POV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_POU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POU_CHILDREN),
+static WORD_POU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POU_CHILDREN),
     value: None,
 };
 
-pub static WORD_POU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("int"),
         dictgen::InsensitiveStr::Ascii("late"),
@@ -72789,12 +72789,12 @@ pub static WORD_POU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_POT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POT_CHILDREN),
+static WORD_POT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POT_CHILDREN),
     value: None,
 };
 
-pub static WORD_POT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atoe"),
         dictgen::InsensitiveStr::Ascii("atos"),
@@ -72866,12 +72866,12 @@ pub static WORD_POT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_POS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POS_CHILDREN),
+static WORD_POS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POS_CHILDREN),
     value: None,
 };
 
-static WORD_POS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_POSA_NODE),
     None,
     None,
@@ -72900,12 +72900,12 @@ static WORD_POS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POST_CHILDREN),
+static WORD_POST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POST_CHILDREN),
     value: None,
 };
 
-pub static WORD_POST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("condtion"),
         dictgen::InsensitiveStr::Ascii("condtions"),
@@ -72981,12 +72981,12 @@ pub static WORD_POST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_POSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POSS_CHILDREN),
+static WORD_POSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POSS_CHILDREN),
     value: None,
 };
 
-static WORD_POSS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POSS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_POSSA_NODE),
     Some(&WORD_POSSB_NODE),
     None,
@@ -73015,12 +73015,12 @@ static WORD_POSS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POSSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSS_CHILDREN),
+static WORD_POSSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ible"),
         dictgen::InsensitiveStr::Ascii("ibly"),
@@ -73029,12 +73029,12 @@ pub static WORD_POSSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_POSSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSO_CHILDREN),
+static WORD_POSSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bily"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -73044,12 +73044,12 @@ pub static WORD_POSSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_POSSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSI_CHILDREN),
+static WORD_POSSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("bbe"),
@@ -73125,12 +73125,12 @@ pub static WORD_POSSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_POSSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSE_CHILDREN),
+static WORD_POSSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ses"),
         dictgen::InsensitiveStr::Ascii("sess"),
@@ -73168,12 +73168,12 @@ pub static WORD_POSSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_POSSB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSB_CHILDREN),
+static WORD_POSSB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSB_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ile"),
         dictgen::InsensitiveStr::Ascii("ily"),
@@ -73189,12 +73189,12 @@ pub static WORD_POSSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_POSSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSA_CHILDREN),
+static WORD_POSSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilites"),
         dictgen::InsensitiveStr::Ascii("bilities"),
@@ -73216,12 +73216,12 @@ pub static WORD_POSSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_POSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSP_CHILDREN),
+static WORD_POSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("one"),
         dictgen::InsensitiveStr::Ascii("oned"),
@@ -73231,23 +73231,23 @@ pub static WORD_POSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_POSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSO_CHILDREN),
+static WORD_POSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["position"]],
     range: 4..=4,
 };
 
-static WORD_POSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POSI_CHILDREN),
+static WORD_POSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POSI_CHILDREN),
     value: None,
 };
 
-static WORD_POSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POSI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_POSIB_NODE),
     Some(&WORD_POSIC_NODE),
@@ -73276,12 +73276,12 @@ static WORD_POSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POSIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIT_CHILDREN),
+static WORD_POSIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("evely"),
         dictgen::InsensitiveStr::Ascii("ioing"),
@@ -73375,12 +73375,12 @@ pub static WORD_POSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_POSIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIS_CHILDREN),
+static WORD_POSIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("ition"),
@@ -73398,12 +73398,12 @@ pub static WORD_POSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_POSIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIO_CHILDREN),
+static WORD_POSIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -73419,12 +73419,12 @@ pub static WORD_POSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_POSII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSII_CHILDREN),
+static WORD_POSII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSII_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tive"),
         dictgen::InsensitiveStr::Ascii("tives"),
@@ -73440,12 +73440,12 @@ pub static WORD_POSII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_POSIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIF_CHILDREN),
+static WORD_POSIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -73454,23 +73454,23 @@ pub static WORD_POSIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_POSIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIC_CHILDREN),
+static WORD_POSIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ional")],
     values: &[&["positional"]],
     range: 5..=5,
 };
 
-static WORD_POSIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIB_CHILDREN),
+static WORD_POSIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilities"),
         dictgen::InsensitiveStr::Ascii("ility"),
@@ -73490,12 +73490,12 @@ pub static WORD_POSIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_POSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSE_CHILDREN),
+static WORD_POSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esions"),
         dictgen::InsensitiveStr::Ascii("ss"),
@@ -73517,12 +73517,12 @@ pub static WORD_POSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_POSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSA_CHILDREN),
+static WORD_POSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tive"),
         dictgen::InsensitiveStr::Ascii("tives"),
@@ -73532,12 +73532,12 @@ pub static WORD_POSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_POR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POR_CHILDREN),
+static WORD_POR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POR_CHILDREN),
     value: None,
 };
 
-static WORD_POR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PORA_NODE),
     Some(&WORD_PORB_NODE),
     Some(&WORD_PORC_NODE),
@@ -73566,12 +73566,12 @@ static WORD_POR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PORV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORV_CHILDREN),
+static WORD_PORV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -73601,12 +73601,12 @@ pub static WORD_PORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_PORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORT_CHILDREN),
+static WORD_PORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abel"),
         dictgen::InsensitiveStr::Ascii("abillity"),
@@ -73694,12 +73694,12 @@ pub static WORD_PORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PORS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORS_CHILDREN),
+static WORD_PORS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alin"),
         dictgen::InsensitiveStr::Ascii("han"),
@@ -73709,12 +73709,12 @@ pub static WORD_PORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PORP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORP_CHILDREN),
+static WORD_PORP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erties"),
         dictgen::InsensitiveStr::Ascii("erty"),
@@ -73742,12 +73742,12 @@ pub static WORD_PORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PORO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORO_CHILDREN),
+static WORD_PORO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tocol"),
         dictgen::InsensitiveStr::Ascii("tocols"),
@@ -73756,12 +73756,12 @@ pub static WORD_PORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORN_CHILDREN),
+static WORD_PORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agraphy"),
         dictgen::InsensitiveStr::Ascii("ograghy"),
@@ -73789,34 +73789,34 @@ pub static WORD_PORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_PORM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORM_CHILDREN),
+static WORD_PORM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etheus")],
     values: &[&["prometheus"]],
     range: 6..=6,
 };
 
-static WORD_PORL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORL_CHILDREN),
+static WORD_PORL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etariat")],
     values: &[&["proletariat"]],
     range: 7..=7,
 };
 
-static WORD_PORJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORJ_CHILDREN),
+static WORD_PORJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ectiles"),
@@ -73832,12 +73832,12 @@ pub static WORD_PORJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORI_CHILDREN),
+static WORD_PORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("feral"),
         dictgen::InsensitiveStr::Ascii("od"),
@@ -73846,12 +73846,12 @@ pub static WORD_PORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORG_CHILDREN),
+static WORD_PORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ram"),
         dictgen::InsensitiveStr::Ascii("ramme"),
@@ -73871,12 +73871,12 @@ pub static WORD_PORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORF_CHILDREN),
+static WORD_PORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("olio"),
         dictgen::InsensitiveStr::Ascii("tolio"),
@@ -73885,34 +73885,34 @@ pub static WORD_PORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORE_CHILDREN),
+static WORD_PORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("clain")],
     values: &[&["porcelain"]],
     range: 5..=5,
 };
 
-static WORD_PORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORD_CHILDREN),
+static WORD_PORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uct")],
     values: &[&["product"]],
     range: 3..=3,
 };
 
-static WORD_PORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORC_CHILDREN),
+static WORD_PORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elan"),
         dictgen::InsensitiveStr::Ascii("elian"),
@@ -73938,12 +73938,12 @@ pub static WORD_PORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PORB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORB_CHILDREN),
+static WORD_PORB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("lem"),
@@ -73953,23 +73953,23 @@ pub static WORD_PORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORA_CHILDREN),
+static WORD_PORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lized")],
     values: &[&["polarized"]],
     range: 5..=5,
 };
 
-static WORD_POP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POP_CHILDREN),
+static WORD_POP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POP_CHILDREN),
     value: None,
 };
 
-pub static WORD_POP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eree"),
@@ -74077,12 +74077,12 @@ pub static WORD_POP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_POO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POO_CHILDREN),
+static WORD_POO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("int"),
         dictgen::InsensitiveStr::Ascii("inted"),
@@ -74104,12 +74104,12 @@ pub static WORD_POO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_PON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PON_CHILDREN),
+static WORD_PON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PON_CHILDREN),
     value: None,
 };
 
-pub static WORD_PON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("int"),
         dictgen::InsensitiveStr::Ascii("inted"),
@@ -74151,12 +74151,12 @@ pub static WORD_PON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_POM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POM_CHILDREN),
+static WORD_POM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POM_CHILDREN),
     value: None,
 };
 
-pub static WORD_POM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egranite"),
         dictgen::InsensitiveStr::Ascii("egrenate"),
@@ -74172,12 +74172,12 @@ pub static WORD_POM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_POL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POL_CHILDREN),
+static WORD_POL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POL_CHILDREN),
     value: None,
 };
 
-static WORD_POL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_POLA_NODE),
     None,
     Some(&WORD_POLC_NODE),
@@ -74206,12 +74206,12 @@ static WORD_POL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLY_CHILDREN),
+static WORD_POLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("edral"),
@@ -74263,12 +74263,12 @@ pub static WORD_POLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_POLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLU_CHILDREN),
+static WORD_POLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("late"),
         dictgen::InsensitiveStr::Ascii("lated"),
@@ -74294,12 +74294,12 @@ pub static WORD_POLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_POLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLT_CHILDREN),
+static WORD_POLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -74317,23 +74317,23 @@ pub static WORD_POLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_POLP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLP_CHILDREN),
+static WORD_POLP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLP_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ulate")],
     values: &[&["populate"]],
     range: 5..=5,
 };
 
-static WORD_POLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLO_CHILDREN),
+static WORD_POLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cies"),
         dictgen::InsensitiveStr::Ascii("cy"),
@@ -74359,12 +74359,12 @@ pub static WORD_POLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_POLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLL_CHILDREN),
+static WORD_POLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enate"),
         dictgen::InsensitiveStr::Ascii("try"),
@@ -74373,12 +74373,12 @@ pub static WORD_POLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_POLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLI_CHILDREN),
+static WORD_POLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("cally"),
@@ -74470,12 +74470,12 @@ pub static WORD_POLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_POLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLG_CHILDREN),
+static WORD_POLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("ons"),
@@ -74486,12 +74486,12 @@ pub static WORD_POLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_POLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLC_CHILDREN),
+static WORD_POLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("iy"),
@@ -74501,34 +74501,34 @@ pub static WORD_POLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_POLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLA_CHILDREN),
+static WORD_POLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("riy")],
     values: &[&["polarity"]],
     range: 3..=3,
 };
 
-static WORD_POK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POK_CHILDREN),
+static WORD_POK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POK_CHILDREN),
     value: None,
 };
 
-pub static WORD_POK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["pocket"]],
     range: 2..=2,
 };
 
-static WORD_POJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POJ_CHILDREN),
+static WORD_POJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_POJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ecting"),
@@ -74558,12 +74558,12 @@ pub static WORD_POJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_POI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POI_CHILDREN),
+static WORD_POI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POI_CHILDREN),
     value: None,
 };
 
-static WORD_POI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_POIC_NODE),
@@ -74592,23 +74592,23 @@ static WORD_POI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIU_CHILDREN),
+static WORD_POIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nter")],
     values: &[&["pointer"]],
     range: 4..=4,
 };
 
-static WORD_POIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIT_CHILDREN),
+static WORD_POIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIT_CHILDREN),
     value: Some(&["point"]),
 };
 
-pub static WORD_POIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -74650,12 +74650,12 @@ pub static WORD_POIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_POIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIS_CHILDREN),
+static WORD_POIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ioning"),
@@ -74703,12 +74703,12 @@ pub static WORD_POIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_POIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIN_CHILDREN),
+static WORD_POIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIN_CHILDREN),
     value: Some(&["point"]),
 };
 
-pub static WORD_POIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dcloud"),
@@ -74756,34 +74756,34 @@ pub static WORD_POIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_POIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIM_CHILDREN),
+static WORD_POIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["point"]],
     range: 1..=1,
 };
 
-static WORD_POIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIL_CHILDREN),
+static WORD_POIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cy")],
     values: &[&["policy"]],
     range: 2..=2,
 };
 
-static WORD_POII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POII_CHILDREN),
+static WORD_POII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POII_CHILDREN),
     value: None,
 };
 
-pub static WORD_POII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("nter"),
@@ -74793,23 +74793,23 @@ pub static WORD_POII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_POIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIG_CHILDREN),
+static WORD_POIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nat")],
     values: &[&["poignant"]],
     range: 3..=3,
 };
 
-static WORD_POIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIC_CHILDREN),
+static WORD_POIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -74818,23 +74818,23 @@ pub static WORD_POIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_POG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POG_CHILDREN),
+static WORD_POG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POG_CHILDREN),
     value: None,
 };
 
-pub static WORD_POG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ress")],
     values: &[&["progress"]],
     range: 4..=4,
 };
 
-static WORD_POE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POE_CHILDREN),
+static WORD_POE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POE_CHILDREN),
     value: None,
 };
 
-pub static WORD_POE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nis"),
         dictgen::InsensitiveStr::Ascii("ntial"),
@@ -74866,12 +74866,12 @@ pub static WORD_POE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_POD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POD_CHILDREN),
+static WORD_POD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POD_CHILDREN),
     value: None,
 };
 
-pub static WORD_POD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emso"),
         dictgen::InsensitiveStr::Ascii("fie"),
@@ -74882,12 +74882,12 @@ pub static WORD_POD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_POC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POC_CHILDREN),
+static WORD_POC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POC_CHILDREN),
     value: None,
 };
 
-pub static WORD_POC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("essed"),
@@ -74901,12 +74901,12 @@ pub static WORD_POC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_POB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POB_CHILDREN),
+static WORD_POB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POB_CHILDREN),
     value: None,
 };
 
-pub static WORD_POB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("ular"),
@@ -74916,23 +74916,23 @@ pub static WORD_POB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_PN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PN_CHILDREN),
+static WORD_PN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PN_CHILDREN),
     value: Some(&["on"]),
 };
 
-pub static WORD_PN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atheon")],
     values: &[&["pantheon"]],
     range: 6..=6,
 };
 
-static WORD_PL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PL_CHILDREN),
+static WORD_PL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PL_CHILDREN),
     value: None,
 };
 
-static WORD_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PLA_NODE),
     None,
     Some(&WORD_PLC_NODE),
@@ -74961,23 +74961,23 @@ static WORD_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLY_CHILDREN),
+static WORD_PLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("otropy")],
     values: &[&["pleiotropy"]],
     range: 6..=6,
 };
 
-static WORD_PLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLU_CHILDREN),
+static WORD_PLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gable"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -75005,12 +75005,12 @@ pub static WORD_PLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_PLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLT_CHILDREN),
+static WORD_PLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("forms"),
@@ -75019,12 +75019,12 @@ pub static WORD_PLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_PLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLO_CHILDREN),
+static WORD_PLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arized"),
         dictgen::InsensitiveStr::Ascii("retariat"),
@@ -75050,23 +75050,23 @@ pub static WORD_PLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_PLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLL_CHILDREN),
+static WORD_PLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atforms")],
     values: &[&["platforms"]],
     range: 7..=7,
 };
 
-static WORD_PLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLI_CHILDREN),
+static WORD_PLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -75076,23 +75076,23 @@ pub static WORD_PLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_PLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLG_CHILDREN),
+static WORD_PLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uin")],
     values: &[&["plugin"]],
     range: 3..=3,
 };
 
-static WORD_PLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLE_CHILDREN),
+static WORD_PLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aase"),
         dictgen::InsensitiveStr::Ascii("ace"),
@@ -75158,12 +75158,12 @@ pub static WORD_PLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_PLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLC_CHILDREN),
+static WORD_PLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aebo"),
@@ -75191,12 +75191,12 @@ pub static WORD_PLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PLA_CHILDREN),
+static WORD_PLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PLA_CHILDREN),
     value: None,
 };
 
-static WORD_PLA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PLA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_PLAB_NODE),
     Some(&WORD_PLAC_NODE),
@@ -75225,12 +75225,12 @@ static WORD_PLA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PLAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAY_CHILDREN),
+static WORD_PLAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("around"),
@@ -75318,12 +75318,12 @@ pub static WORD_PLAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_PLAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAU_CHILDREN),
+static WORD_PLAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sability"),
         dictgen::InsensitiveStr::Ascii("sable"),
@@ -75343,12 +75343,12 @@ pub static WORD_PLAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_PLAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAT_CHILDREN),
+static WORD_PLAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeu"),
         dictgen::InsensitiveStr::Ascii("eu"),
@@ -75446,12 +75446,12 @@ pub static WORD_PLAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PLAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAS_CHILDREN),
+static WORD_PLAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAS_CHILDREN),
     value: Some(&["plays"]),
 };
 
-pub static WORD_PLAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -75485,12 +75485,12 @@ pub static WORD_PLAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_PLAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAR_CHILDREN),
+static WORD_PLAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("former"),
@@ -75499,12 +75499,12 @@ pub static WORD_PLAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PLAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAN_CHILDREN),
+static WORD_PLAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atery"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -75552,12 +75552,12 @@ pub static WORD_PLAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PLAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAL_CHILDREN),
+static WORD_PLAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("forms"),
@@ -75566,12 +75566,12 @@ pub static WORD_PLAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PLAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAI_CHILDREN),
+static WORD_PLAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("garism"),
         dictgen::InsensitiveStr::Ascii("ntest"),
@@ -75580,12 +75580,12 @@ pub static WORD_PLAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PLAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAG_CHILDREN),
+static WORD_PLAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("airism"),
         dictgen::InsensitiveStr::Ascii("arisim"),
@@ -75615,12 +75615,12 @@ pub static WORD_PLAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PLAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAF_CHILDREN),
+static WORD_PLAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orm"),
         dictgen::InsensitiveStr::Ascii("orms"),
@@ -75631,12 +75631,12 @@ pub static WORD_PLAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_PLAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAE_CHILDREN),
+static WORD_PLAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("stine"),
@@ -75652,23 +75652,23 @@ pub static WORD_PLAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PLAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAD_CHILDREN),
+static WORD_PLAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAD_CHILDREN),
     value: Some(&["plaid", "plead"]),
 };
 
-pub static WORD_PLAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["plaided", "pleaded"]],
     range: 2..=2,
 };
 
-static WORD_PLAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAC_CHILDREN),
+static WORD_PLAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ebro"),
@@ -75724,34 +75724,34 @@ pub static WORD_PLAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PLAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAB_CHILDREN),
+static WORD_PLAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eswalker")],
     values: &[&["planeswalker"]],
     range: 8..=8,
 };
 
-static WORD_PK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PK_CHILDREN),
+static WORD_PK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PK_CHILDREN),
     value: None,
 };
 
-pub static WORD_PK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aythroughs")],
     values: &[&["playthroughs"]],
     range: 10..=10,
 };
 
-static WORD_PI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PI_CHILDREN),
+static WORD_PI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PI_CHILDREN),
     value: None,
 };
 
-static WORD_PI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PIA_NODE),
     Some(&WORD_PIB_NODE),
     Some(&WORD_PIC_NODE),
@@ -75780,12 +75780,12 @@ static WORD_PI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIX_CHILDREN),
+static WORD_PIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elx"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -75794,12 +75794,12 @@ pub static WORD_PIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_PIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIV_CHILDREN),
+static WORD_PIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ott"),
         dictgen::InsensitiveStr::Ascii("otting"),
@@ -75808,12 +75808,12 @@ pub static WORD_PIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_PIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIT_CHILDREN),
+static WORD_PIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chferks"),
         dictgen::InsensitiveStr::Ascii("chfolks"),
@@ -75849,12 +75849,12 @@ pub static WORD_PIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIR_CHILDREN),
+static WORD_PIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eced"),
         dictgen::InsensitiveStr::Ascii("ric"),
@@ -75863,12 +75863,12 @@ pub static WORD_PIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_PIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIP_CHILDREN),
+static WORD_PIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eine"),
         dictgen::InsensitiveStr::Ascii("eines"),
@@ -75910,12 +75910,12 @@ pub static WORD_PIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_PIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIO_CHILDREN),
+static WORD_PIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lting"),
         dictgen::InsensitiveStr::Ascii("neeer"),
@@ -75939,12 +75939,12 @@ pub static WORD_PIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_PIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIN_CHILDREN),
+static WORD_PIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancle"),
         dictgen::InsensitiveStr::Ascii("apple"),
@@ -75984,12 +75984,12 @@ pub static WORD_PIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIM_CHILDREN),
+static WORD_PIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("xap"),
         dictgen::InsensitiveStr::Ascii("xaps"),
@@ -75998,12 +75998,12 @@ pub static WORD_PIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_PIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIL_CHILDREN),
+static WORD_PIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("girm"),
@@ -76037,12 +76037,12 @@ pub static WORD_PIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PIJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIJ_CHILDREN),
+static WORD_PIJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eon"),
         dictgen::InsensitiveStr::Ascii("eons"),
@@ -76053,12 +76053,12 @@ pub static WORD_PIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_PIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIG_CHILDREN),
+static WORD_PIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -76086,12 +76086,12 @@ pub static WORD_PIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_PIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIE_CHILDREN),
+static WORD_PIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceweise"),
         dictgen::InsensitiveStr::Ascii("cewice"),
@@ -76109,12 +76109,12 @@ pub static WORD_PIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_PIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIC_CHILDREN),
+static WORD_PIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -76194,23 +76194,23 @@ pub static WORD_PIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_PIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIB_CHILDREN),
+static WORD_PIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lisher")],
     values: &[&["publisher"]],
     range: 6..=6,
 };
 
-static WORD_PIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIA_CHILDREN),
+static WORD_PIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nkillers"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -76224,12 +76224,12 @@ pub static WORD_PIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_PH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PH_CHILDREN),
+static WORD_PH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PH_CHILDREN),
     value: None,
 };
 
-static WORD_PH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PHA_NODE),
     None,
     None,
@@ -76258,12 +76258,12 @@ static WORD_PH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PHY_CHILDREN),
+static WORD_PHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PHY_CHILDREN),
     value: None,
 };
 
-static WORD_PHY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PHY_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_PHYC_NODE),
@@ -76292,12 +76292,12 @@ static WORD_PHY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PHYT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYT_CHILDREN),
+static WORD_PHYT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hon"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -76306,12 +76306,12 @@ pub static WORD_PHYT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PHYS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYS_CHILDREN),
+static WORD_PHYS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("cedelic"),
@@ -76407,12 +76407,12 @@ pub static WORD_PHYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PHYL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYL_CHILDREN),
+static WORD_PHYL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("osophical"),
         dictgen::InsensitiveStr::Ascii("osophically"),
@@ -76421,12 +76421,12 @@ pub static WORD_PHYL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=11,
 };
 
-static WORD_PHYI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYI_CHILDREN),
+static WORD_PHYI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("scal"),
         dictgen::InsensitiveStr::Ascii("scally"),
@@ -76444,12 +76444,12 @@ pub static WORD_PHYI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PHYC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYC_CHILDREN),
+static WORD_PHYC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hedelics"),
         dictgen::InsensitiveStr::Ascii("hiatrist"),
@@ -76481,12 +76481,12 @@ pub static WORD_PHYC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_PHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHT_CHILDREN),
+static WORD_PHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("read"),
         dictgen::InsensitiveStr::Ascii("reads"),
@@ -76495,12 +76495,12 @@ pub static WORD_PHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_PHS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHS_CHILDREN),
+static WORD_PHS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ycologically"),
@@ -76532,12 +76532,12 @@ pub static WORD_PHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_PHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHR_CHILDREN),
+static WORD_PHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amaceutical"),
         dictgen::InsensitiveStr::Ascii("amacist"),
@@ -76547,12 +76547,12 @@ pub static WORD_PHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_PHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHO_CHILDREN),
+static WORD_PHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("entic"),
@@ -76666,12 +76666,12 @@ pub static WORD_PHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PHL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHL_CHILDREN),
+static WORD_PHL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("em"),
         dictgen::InsensitiveStr::Ascii("ema"),
@@ -76691,12 +76691,12 @@ pub static WORD_PHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PHI_CHILDREN),
+static WORD_PHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PHI_CHILDREN),
     value: None,
 };
 
-static WORD_PHI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PHI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PHIA_NODE),
     None,
     None,
@@ -76725,12 +76725,12 @@ static WORD_PHI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PHIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHIS_CHILDREN),
+static WORD_PHIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -76750,12 +76750,12 @@ pub static WORD_PHIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PHIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHIL_CHILDREN),
+static WORD_PHIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adalphia"),
         dictgen::InsensitiveStr::Ascii("adelhpia"),
@@ -76885,23 +76885,23 @@ pub static WORD_PHIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=12,
 };
 
-static WORD_PHIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHIA_CHILDREN),
+static WORD_PHIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ldelphia")],
     values: &[&["philadelphia"]],
     range: 8..=8,
 };
 
-static WORD_PHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHE_CHILDREN),
+static WORD_PHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("monena"),
         dictgen::InsensitiveStr::Ascii("monenon"),
@@ -76961,12 +76961,12 @@ pub static WORD_PHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_PHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHA_CHILDREN),
+static WORD_PHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nthom"),
         dictgen::InsensitiveStr::Ascii("ntoom"),
@@ -77058,12 +77058,12 @@ pub static WORD_PHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_PE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PE_CHILDREN),
+static WORD_PE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PE_CHILDREN),
     value: None,
 };
 
-static WORD_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PEA_NODE),
     Some(&WORD_PEB_NODE),
     Some(&WORD_PEC_NODE),
@@ -77092,34 +77092,34 @@ static WORD_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_PEZ_NODE),
 ];
 
-static WORD_PEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEZ_CHILDREN),
+static WORD_PEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ier")],
     values: &[&["bezier"]],
     range: 3..=3,
 };
 
-static WORD_PEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEW_CHILDREN),
+static WORD_PEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("der")],
     values: &[&["lewder", "pewter", "powder"]],
     range: 3..=3,
 };
 
-static WORD_PEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEV_CHILDREN),
+static WORD_PEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -77128,23 +77128,23 @@ pub static WORD_PEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_PEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEU_CHILDREN),
+static WORD_PEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sdo")],
     values: &[&["pseudo"]],
     range: 3..=3,
 };
 
-static WORD_PET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PET_CHILDREN),
+static WORD_PET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PET_CHILDREN),
     value: None,
 };
 
-pub static WORD_PET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etion"),
         dictgen::InsensitiveStr::Ascii("rolem"),
@@ -77155,12 +77155,12 @@ pub static WORD_PET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_PES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PES_CHILDREN),
+static WORD_PES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PES_CHILDREN),
     value: None,
 };
 
-pub static WORD_PES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itcides"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -77202,12 +77202,12 @@ pub static WORD_PES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PER_CHILDREN),
+static WORD_PER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PER_CHILDREN),
     value: None,
 };
 
-static WORD_PER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PERA_NODE),
     None,
     Some(&WORD_PERC_NODE),
@@ -77236,23 +77236,23 @@ static WORD_PER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERX_CHILDREN),
+static WORD_PERX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oide")],
     values: &[&["peroxide"]],
     range: 4..=4,
 };
 
-static WORD_PERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERV_CHILDREN),
+static WORD_PERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ail"),
         dictgen::InsensitiveStr::Ascii("ailing"),
@@ -77280,23 +77280,23 @@ pub static WORD_PERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERU_CHILDREN),
+static WORD_PERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("saded")],
     values: &[&["persuaded"]],
     range: 5..=5,
 };
 
-static WORD_PERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERT_CHILDREN),
+static WORD_PERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("ended"),
@@ -77368,12 +77368,12 @@ pub static WORD_PERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PERS_CHILDREN),
+static WORD_PERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PERS_CHILDREN),
     value: None,
 };
 
-static WORD_PERS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PERS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PERSA_NODE),
     None,
     Some(&WORD_PERSC_NODE),
@@ -77402,34 +77402,34 @@ static WORD_PERS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERSW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSW_CHILDREN),
+static WORD_PERSW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("asion")],
     values: &[&["persuasion"]],
     range: 5..=5,
 };
 
-static WORD_PERSV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSV_CHILDREN),
+static WORD_PERSV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("asive")],
     values: &[&["persuasive"]],
     range: 5..=5,
 };
 
-static WORD_PERSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSU_CHILDREN),
+static WORD_PERSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("asian"),
@@ -77481,23 +77481,23 @@ pub static WORD_PERSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PERST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERST_CHILDREN),
+static WORD_PERST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERST_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ige")],
     values: &[&["prestige"]],
     range: 3..=3,
 };
 
-static WORD_PERSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSS_CHILDREN),
+static WORD_PERSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ious"),
         dictgen::InsensitiveStr::Ascii("iously"),
@@ -77513,12 +77513,12 @@ pub static WORD_PERSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PERSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSP_CHILDREN),
+static WORD_PERSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecitve"),
         dictgen::InsensitiveStr::Ascii("ecitves"),
@@ -77540,12 +77540,12 @@ pub static WORD_PERSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PERSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSO_CHILDREN),
+static WORD_PERSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anl"),
         dictgen::InsensitiveStr::Ascii("anlly"),
@@ -77611,23 +77611,23 @@ pub static WORD_PERSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PERSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSM_CHILDREN),
+static WORD_PERSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("issions")],
     values: &[&["permissions"]],
     range: 7..=7,
 };
 
-static WORD_PERSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSI_CHILDREN),
+static WORD_PERSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cuted"),
         dictgen::InsensitiveStr::Ascii("cution"),
@@ -77675,12 +77675,12 @@ pub static WORD_PERSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PERSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSH_CHILDREN),
+static WORD_PERSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("is"),
         dictgen::InsensitiveStr::Ascii("isly"),
@@ -77696,12 +77696,12 @@ pub static WORD_PERSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PERSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSE_CHILDREN),
+static WORD_PERSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctive"),
         dictgen::InsensitiveStr::Ascii("ctives"),
@@ -77783,12 +77783,12 @@ pub static WORD_PERSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PERSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSC_CHILDREN),
+static WORD_PERSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eptive"),
         dictgen::InsensitiveStr::Ascii("iuos"),
@@ -77812,12 +77812,12 @@ pub static WORD_PERSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PERSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSA_CHILDREN),
+static WORD_PERSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -77837,12 +77837,12 @@ pub static WORD_PERSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_PERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERR_CHILDREN),
+static WORD_PERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ogative"),
         dictgen::InsensitiveStr::Ascii("ror"),
@@ -77851,12 +77851,12 @@ pub static WORD_PERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERP_CHILDREN),
+static WORD_PERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aid"),
         dictgen::InsensitiveStr::Ascii("andicular"),
@@ -77982,12 +77982,12 @@ pub static WORD_PERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_PERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERO_CHILDREN),
+static WORD_PERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dically"),
         dictgen::InsensitiveStr::Ascii("endicular"),
@@ -78033,12 +78033,12 @@ pub static WORD_PERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERN_CHILDREN),
+static WORD_PERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ament"),
         dictgen::InsensitiveStr::Ascii("amently"),
@@ -78047,12 +78047,12 @@ pub static WORD_PERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PERM_CHILDREN),
+static WORD_PERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PERM_CHILDREN),
     value: None,
 };
 
-static WORD_PERM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PERM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PERMA_NODE),
     None,
     None,
@@ -78081,12 +78081,12 @@ static WORD_PERM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMU_CHILDREN),
+static WORD_PERMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atate"),
         dictgen::InsensitiveStr::Ascii("atated"),
@@ -78126,23 +78126,23 @@ pub static WORD_PERMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PERMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMT_CHILDREN),
+static WORD_PERMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uation")],
     values: &[&["permutation"]],
     range: 6..=6,
 };
 
-static WORD_PERMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMS_CHILDREN),
+static WORD_PERMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sion"),
         dictgen::InsensitiveStr::Ascii("sions"),
@@ -78151,23 +78151,23 @@ pub static WORD_PERMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PERMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMO_CHILDREN),
+static WORD_PERMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rmance")],
     values: &[&["performance"]],
     range: 6..=6,
 };
 
-static WORD_PERMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMM_CHILDREN),
+static WORD_PERMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ission"),
         dictgen::InsensitiveStr::Ascii("issions"),
@@ -78176,12 +78176,12 @@ pub static WORD_PERMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_PERMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMI_CHILDREN),
+static WORD_PERMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ere"),
@@ -78255,12 +78255,12 @@ pub static WORD_PERMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PERME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERME_CHILDREN),
+static WORD_PERME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERME_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nant"),
         dictgen::InsensitiveStr::Ascii("nantly"),
@@ -78280,12 +78280,12 @@ pub static WORD_PERME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PERMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMA_CHILDREN),
+static WORD_PERMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -78321,12 +78321,12 @@ pub static WORD_PERMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERL_CHILDREN),
+static WORD_PERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciritc"),
         dictgen::InsensitiveStr::Ascii("iferate"),
@@ -78346,12 +78346,12 @@ pub static WORD_PERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_PERJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERJ_CHILDREN),
+static WORD_PERJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ery"),
         dictgen::InsensitiveStr::Ascii("orative"),
@@ -78360,12 +78360,12 @@ pub static WORD_PERJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERI_CHILDREN),
+static WORD_PERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("cings"),
@@ -78473,12 +78473,12 @@ pub static WORD_PERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PERH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERH_CHILDREN),
+static WORD_PERH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abs"),
         dictgen::InsensitiveStr::Ascii("arps"),
@@ -78502,12 +78502,12 @@ pub static WORD_PERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PERF_CHILDREN),
+static WORD_PERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PERF_CHILDREN),
     value: None,
 };
 
-static WORD_PERF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PERF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -78536,12 +78536,12 @@ static WORD_PERF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFU_CHILDREN),
+static WORD_PERFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rd"),
@@ -78565,12 +78565,12 @@ pub static WORD_PERFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_PERFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFR_CHILDREN),
+static WORD_PERFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("om"),
@@ -78596,12 +78596,12 @@ pub static WORD_PERFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PERFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PERFO_CHILDREN),
+static WORD_PERFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PERFO_CHILDREN),
     value: None,
 };
 
-static WORD_PERFO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PERFO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -78630,12 +78630,12 @@ static WORD_PERFO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERFOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFOR_CHILDREN),
+static WORD_PERFOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFOR_CHILDREN),
     value: Some(&["perform"]),
 };
 
-pub static WORD_PERFOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("amed"),
@@ -78715,23 +78715,23 @@ pub static WORD_PERFOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_PERFOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFOO_CHILDREN),
+static WORD_PERFOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("m")],
     values: &[&["perfume", "perform"]],
     range: 1..=1,
 };
 
-static WORD_PERFOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFOM_CHILDREN),
+static WORD_PERFOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFOM_CHILDREN),
     value: Some(&["perform"]),
 };
 
-pub static WORD_PERFOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amce"),
         dictgen::InsensitiveStr::Ascii("amces"),
@@ -78827,12 +78827,12 @@ pub static WORD_PERFOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PERFOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFOE_CHILDREN),
+static WORD_PERFOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mamce"),
@@ -78870,34 +78870,34 @@ pub static WORD_PERFOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PERFM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFM_CHILDREN),
+static WORD_PERFM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ormance")],
     values: &[&["performance"]],
     range: 7..=7,
 };
 
-static WORD_PERFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFI_CHILDREN),
+static WORD_PERFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("x")],
     values: &[&["prefix"]],
     range: 1..=1,
 };
 
-static WORD_PERFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFE_CHILDREN),
+static WORD_PERFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ccion"),
@@ -78995,12 +78995,12 @@ pub static WORD_PERFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERE_CHILDREN),
+static WORD_PERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("miter"),
         dictgen::InsensitiveStr::Ascii("nially"),
@@ -79020,12 +79020,12 @@ pub static WORD_PERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERD_CHILDREN),
+static WORD_PERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ators"),
         dictgen::InsensitiveStr::Ascii("icament"),
@@ -79051,12 +79051,12 @@ pub static WORD_PERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERC_CHILDREN),
+static WORD_PERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antage"),
         dictgen::InsensitiveStr::Ascii("antages"),
@@ -79158,12 +79158,12 @@ pub static WORD_PERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERA_CHILDREN),
+static WORD_PERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("phs"),
@@ -79172,12 +79172,12 @@ pub static WORD_PERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEP_CHILDREN),
+static WORD_PEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("le"),
@@ -79209,12 +79209,12 @@ pub static WORD_PEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_PEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEO_CHILDREN),
+static WORD_PEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dphile"),
         dictgen::InsensitiveStr::Ascii("dphiles"),
@@ -79246,12 +79246,12 @@ pub static WORD_PEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_PEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PEN_CHILDREN),
+static WORD_PEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PEN_CHILDREN),
     value: None,
 };
 
-static WORD_PEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PENA_NODE),
     None,
     Some(&WORD_PENC_NODE),
@@ -79280,34 +79280,34 @@ static WORD_PEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PENW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENW_CHILDREN),
+static WORD_PENW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ar")],
     values: &[&["peignoir"]],
     range: 2..=2,
 };
 
-static WORD_PENU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENU_CHILDREN),
+static WORD_PENU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ltimante")],
     values: &[&["penultimate"]],
     range: 8..=8,
 };
 
-static WORD_PENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENT_CHILDREN),
+static WORD_PENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agoon"),
         dictgen::InsensitiveStr::Ascii("alty"),
@@ -79318,12 +79318,12 @@ pub static WORD_PENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PENS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENS_CHILDREN),
+static WORD_PENS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("ino"),
@@ -79343,12 +79343,12 @@ pub static WORD_PENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENN_CHILDREN),
+static WORD_PENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("als"),
@@ -79396,12 +79396,12 @@ pub static WORD_PENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENI_CHILDREN),
+static WORD_PENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cls"),
         dictgen::InsensitiveStr::Ascii("ndg"),
@@ -79433,12 +79433,12 @@ pub static WORD_PENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PENG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENG_CHILDREN),
+static WORD_PENG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iuns"),
         dictgen::InsensitiveStr::Ascii("uines"),
@@ -79468,12 +79468,12 @@ pub static WORD_PENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENE_CHILDREN),
+static WORD_PENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rator"),
         dictgen::InsensitiveStr::Ascii("tracion"),
@@ -79497,12 +79497,12 @@ pub static WORD_PENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_PEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEND_CHILDREN),
+static WORD_PEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antic"),
         dictgen::InsensitiveStr::Ascii("atic"),
@@ -79524,23 +79524,23 @@ pub static WORD_PEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENC_CHILDREN),
+static WORD_PENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iles")],
     values: &[&["pencils"]],
     range: 4..=4,
 };
 
-static WORD_PENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENA_CHILDREN),
+static WORD_PENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lites"),
         dictgen::InsensitiveStr::Ascii("lities"),
@@ -79566,23 +79566,23 @@ pub static WORD_PENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEM_CHILDREN),
+static WORD_PEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("issions")],
     values: &[&["permissions"]],
     range: 7..=7,
 };
 
-static WORD_PEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEL_CHILDREN),
+static WORD_PEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("oponnes"),
@@ -79591,12 +79591,12 @@ pub static WORD_PEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEI_CHILDREN),
+static WORD_PEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cemeal"),
@@ -79628,34 +79628,34 @@ pub static WORD_PEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_PEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEH_CHILDREN),
+static WORD_PEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aps")],
     values: &[&["perhaps"]],
     range: 3..=3,
 };
 
-static WORD_PEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEG_CHILDREN),
+static WORD_PEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["page"]],
     range: 1..=1,
 };
 
-static WORD_PEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEF_CHILDREN),
+static WORD_PEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ectly"),
@@ -79701,12 +79701,12 @@ pub static WORD_PEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEE_CHILDREN),
+static WORD_PEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dmont"),
         dictgen::InsensitiveStr::Ascii("dmonts"),
@@ -79728,12 +79728,12 @@ pub static WORD_PEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PED_CHILDREN),
+static WORD_PED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PED_CHILDREN),
     value: None,
 };
 
-pub static WORD_PED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antisch"),
         dictgen::InsensitiveStr::Ascii("astal"),
@@ -79791,12 +79791,12 @@ pub static WORD_PED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_PEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEC_CHILDREN),
+static WORD_PEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entage"),
         dictgen::InsensitiveStr::Ascii("ified"),
@@ -79822,12 +79822,12 @@ pub static WORD_PEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_PEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEB_CHILDREN),
+static WORD_PEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bels"),
         dictgen::InsensitiveStr::Ascii("bleos"),
@@ -79838,12 +79838,12 @@ pub static WORD_PEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_PEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEA_CHILDREN),
+static WORD_PEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cd"),
         dictgen::InsensitiveStr::Ascii("cefullly"),
@@ -79895,12 +79895,12 @@ pub static WORD_PEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PB_CHILDREN),
+static WORD_PB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lisher"),
         dictgen::InsensitiveStr::Ascii("ulisher"),
@@ -79909,12 +79909,12 @@ pub static WORD_PB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_PA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PA_CHILDREN),
+static WORD_PA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PA_CHILDREN),
     value: None,
 };
 
-static WORD_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PAA_NODE),
     Some(&WORD_PAB_NODE),
     Some(&WORD_PAC_NODE),
@@ -79943,12 +79943,12 @@ static WORD_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAY_CHILDREN),
+static WORD_PAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chedelics"),
         dictgen::InsensitiveStr::Ascii("chiatrist"),
@@ -79984,12 +79984,12 @@ pub static WORD_PAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_PAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAV_CHILDREN),
+static WORD_PAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("illion"),
         dictgen::InsensitiveStr::Ascii("illions"),
@@ -79998,12 +79998,12 @@ pub static WORD_PAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_PAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PAT_CHILDREN),
+static WORD_PAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PAT_CHILDREN),
     value: None,
 };
 
-static WORD_PAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PATA_NODE),
     None,
     Some(&WORD_PATC_NODE),
@@ -80032,12 +80032,12 @@ static WORD_PAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATT_CHILDREN),
+static WORD_PATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ened"),
@@ -80065,12 +80065,12 @@ pub static WORD_PATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATR_CHILDREN),
+static WORD_PATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("airchy"),
         dictgen::InsensitiveStr::Ascii("cik"),
@@ -80150,12 +80150,12 @@ pub static WORD_PATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATI_CHILDREN),
+static WORD_PATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -80191,12 +80191,12 @@ pub static WORD_PATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PATH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATH_CHILDREN),
+static WORD_PATH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alogical"),
         dictgen::InsensitiveStr::Ascii("ame"),
@@ -80242,12 +80242,12 @@ pub static WORD_PATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATE_CHILDREN),
+static WORD_PATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ince"),
         dictgen::InsensitiveStr::Ascii("int"),
@@ -80271,12 +80271,12 @@ pub static WORD_PATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATC_CHILDREN),
+static WORD_PATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hs"),
         dictgen::InsensitiveStr::Ascii("ket"),
@@ -80286,12 +80286,12 @@ pub static WORD_PATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATA_CHILDREN),
+static WORD_PATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meter"),
         dictgen::InsensitiveStr::Ascii("meters"),
@@ -80300,12 +80300,12 @@ pub static WORD_PATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PAS_CHILDREN),
+static WORD_PAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PAS_CHILDREN),
     value: None,
 };
 
-static WORD_PAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PAS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PASA_NODE),
     None,
     Some(&WORD_PASC_NODE),
@@ -80334,12 +80334,12 @@ static WORD_PAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PASW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASW_CHILDREN),
+static WORD_PASW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ord"),
         dictgen::InsensitiveStr::Ascii("ords"),
@@ -80348,23 +80348,23 @@ pub static WORD_PASW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PASU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASU_CHILDREN),
+static WORD_PASU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["pausing"]],
     range: 3..=3,
 };
 
-static WORD_PAST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAST_CHILDREN),
+static WORD_PAST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAST_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eing"),
         dictgen::InsensitiveStr::Ascii("eries"),
@@ -80402,12 +80402,12 @@ pub static WORD_PAST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PASS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASS_CHILDREN),
+static WORD_PASS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("abel"),
@@ -80511,12 +80511,12 @@ pub static WORD_PASS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PASR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASR_CHILDREN),
+static WORD_PASR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -80527,12 +80527,12 @@ pub static WORD_PASR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_PASI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASI_CHILDREN),
+static WORD_PASI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("tioning"),
@@ -80542,23 +80542,23 @@ pub static WORD_PASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PASH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASH_CHILDREN),
+static WORD_PASH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASH_CHILDREN),
     value: Some(&["hash"]),
 };
 
-pub static WORD_PASH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PASE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASE_CHILDREN),
+static WORD_PASE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASE_CHILDREN),
     value: Some(&["pass", "pace", "parse", "phase"]),
 };
 
-pub static WORD_PASE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ngers"),
@@ -80574,12 +80574,12 @@ pub static WORD_PASE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_PASC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASC_CHILDREN),
+static WORD_PASC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heurisation"),
         dictgen::InsensitiveStr::Ascii("heurise"),
@@ -80627,23 +80627,23 @@ pub static WORD_PASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=11,
 };
 
-static WORD_PASA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASA_CHILDREN),
+static WORD_PASA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sword")],
     values: &[&["password"]],
     range: 5..=5,
 };
 
-static WORD_PAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PAR_CHILDREN),
+static WORD_PAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PAR_CHILDREN),
     value: None,
 };
 
-static WORD_PAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARA_NODE),
     None,
     Some(&WORD_PARC_NODE),
@@ -80672,23 +80672,23 @@ static WORD_PAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARY_CHILDREN),
+static WORD_PARY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARY_CHILDREN),
     value: Some(&["party", "parry"]),
 };
 
-pub static WORD_PARY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PART_CHILDREN),
+static WORD_PART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PART_CHILDREN),
     value: None,
 };
 
-static WORD_PART_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PART_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARTA_NODE),
     None,
     Some(&WORD_PARTC_NODE),
@@ -80717,23 +80717,23 @@ static WORD_PART_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTS_CHILDREN),
+static WORD_PARTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ian")],
     values: &[&["partisan"]],
     range: 3..=3,
 };
 
-static WORD_PARTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTO_CHILDREN),
+static WORD_PARTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ls"),
         dictgen::InsensitiveStr::Ascii("nizing"),
@@ -80742,12 +80742,12 @@ pub static WORD_PARTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PARTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTN_CHILDREN),
+static WORD_PARTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erd"),
         dictgen::InsensitiveStr::Ascii("etship"),
@@ -80756,12 +80756,12 @@ pub static WORD_PARTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PARTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PARTI_CHILDREN),
+static WORD_PARTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PARTI_CHILDREN),
     value: None,
 };
 
-static WORD_PARTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PARTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARTIA_NODE),
     None,
     Some(&WORD_PARTIC_NODE),
@@ -80790,23 +80790,23 @@ static WORD_PARTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARTIZ_NODE),
 ];
 
-static WORD_PARTIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIZ_CHILDREN),
+static WORD_PARTIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ipation")],
     values: &[&["participation"]],
     range: 7..=7,
 };
 
-static WORD_PARTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIU_CHILDREN),
+static WORD_PARTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("la"),
         dictgen::InsensitiveStr::Ascii("lar"),
@@ -80822,12 +80822,12 @@ pub static WORD_PARTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_PARTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIT_CHILDREN),
+static WORD_PARTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("icipant"),
@@ -80865,12 +80865,12 @@ pub static WORD_PARTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_PARTIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIS_CHILDREN),
+static WORD_PARTIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -80890,12 +80890,12 @@ pub static WORD_PARTIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PARTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIR_CHILDREN),
+static WORD_PARTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ioned"),
@@ -80911,12 +80911,12 @@ pub static WORD_PARTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PARTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIO_CHILDREN),
+static WORD_PARTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -80940,12 +80940,12 @@ pub static WORD_PARTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_PARTII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTII_CHILDREN),
+static WORD_PARTII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTII_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ton"),
         dictgen::InsensitiveStr::Ascii("toned"),
@@ -80961,23 +80961,23 @@ pub static WORD_PARTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PARTIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIF_CHILDREN),
+static WORD_PARTIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ular")],
     values: &[&["particular"]],
     range: 4..=4,
 };
 
-static WORD_PARTIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIE_CHILDREN),
+static WORD_PARTIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -80986,12 +80986,12 @@ pub static WORD_PARTIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_PARTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PARTIC_CHILDREN),
+static WORD_PARTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PARTIC_CHILDREN),
     value: None,
 };
 
-static WORD_PARTIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PARTIC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARTICA_NODE),
     None,
     None,
@@ -81020,12 +81020,12 @@ static WORD_PARTIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARTICU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICU_CHILDREN),
+static WORD_PARTICU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -81063,12 +81063,12 @@ pub static WORD_PARTICU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_PARTICP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICP_CHILDREN),
+static WORD_PARTICP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -81090,12 +81090,12 @@ pub static WORD_PARTICP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=5,
 };
 
-static WORD_PARTICL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICL_CHILDREN),
+static WORD_PARTICL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -81105,23 +81105,23 @@ pub static WORD_PARTICL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=3,
 };
 
-static WORD_PARTICK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICK_CHILDREN),
+static WORD_PARTICK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICK_CHILDREN),
     value: Some(&["patrick"]),
 };
 
-pub static WORD_PARTICK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PARTICI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICI_CHILDREN),
+static WORD_PARTICI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apnts"),
         dictgen::InsensitiveStr::Ascii("apte"),
@@ -81181,23 +81181,23 @@ pub static WORD_PARTICI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=7,
 };
 
-static WORD_PARTICE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICE_CHILDREN),
+static WORD_PARTICE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICE_CHILDREN),
     value: Some(&["particle"]),
 };
 
-pub static WORD_PARTICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["particle"]],
     range: 1..=1,
 };
 
-static WORD_PARTICA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICA_CHILDREN),
+static WORD_PARTICA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lar"),
@@ -81241,12 +81241,12 @@ pub static WORD_PARTICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_PARTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIA_CHILDREN),
+static WORD_PARTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lially"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -81264,23 +81264,23 @@ pub static WORD_PARTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_PARTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTH_CHILDREN),
+static WORD_PARTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTH_CHILDREN),
     value: Some(&["path"]),
 };
 
-pub static WORD_PARTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PARTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTE_CHILDREN),
+static WORD_PARTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cipant"),
         dictgen::InsensitiveStr::Ascii("cipants"),
@@ -81304,12 +81304,12 @@ pub static WORD_PARTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PARTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTC_CHILDREN),
+static WORD_PARTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hett"),
         dictgen::InsensitiveStr::Ascii("ipate"),
@@ -81327,23 +81327,23 @@ pub static WORD_PARTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PARTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTA_CHILDREN),
+static WORD_PARTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ining")],
     values: &[&["pertaining"]],
     range: 5..=5,
 };
 
-static WORD_PARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARS_CHILDREN),
+static WORD_PARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ef"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -81371,12 +81371,12 @@ pub static WORD_PARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARR_CHILDREN),
+static WORD_PARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alel"),
         dictgen::InsensitiveStr::Ascii("alell"),
@@ -81402,12 +81402,12 @@ pub static WORD_PARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARO_CHILDREN),
+static WORD_PARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cheal"),
         dictgen::InsensitiveStr::Ascii("cheality"),
@@ -81439,12 +81439,12 @@ pub static WORD_PARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_PARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARN_CHILDREN),
+static WORD_PARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oia"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -81466,12 +81466,12 @@ pub static WORD_PARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARM_CHILDREN),
+static WORD_PARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARM_CHILDREN),
     value: Some(&["param", "pram", "parma"]),
 };
 
-pub static WORD_PARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeter"),
         dictgen::InsensitiveStr::Ascii("aeters"),
@@ -81515,12 +81515,12 @@ pub static WORD_PARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARL_CHILDREN),
+static WORD_PARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aiment"),
         dictgen::InsensitiveStr::Ascii("aimentary"),
@@ -81564,12 +81564,12 @@ pub static WORD_PARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_PARK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARK_CHILDREN),
+static WORD_PARK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARK_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -81581,12 +81581,12 @@ pub static WORD_PARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARI_CHILDREN),
+static WORD_PARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("al"),
@@ -81648,34 +81648,34 @@ pub static WORD_PARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARG_CHILDREN),
+static WORD_PARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["large"]],
     range: 1..=1,
 };
 
-static WORD_PARF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARF_CHILDREN),
+static WORD_PARF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ay")],
     values: &[&["parfait"]],
     range: 2..=2,
 };
 
-static WORD_PARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARE_CHILDREN),
+static WORD_PARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llel"),
         dictgen::InsensitiveStr::Ascii("llelogram"),
@@ -81733,23 +81733,23 @@ pub static WORD_PARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARD_CHILDREN),
+static WORD_PARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARD_CHILDREN),
     value: Some(&["part"]),
 };
 
-pub static WORD_PARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARC_CHILDREN),
+static WORD_PARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tical"),
         dictgen::InsensitiveStr::Ascii("tically"),
@@ -81759,12 +81759,12 @@ pub static WORD_PARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PARA_CHILDREN),
+static WORD_PARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PARA_CHILDREN),
     value: None,
 };
 
-static WORD_PARA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PARA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_PARAC_NODE),
@@ -81793,12 +81793,12 @@ static WORD_PARA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAY_CHILDREN),
+static WORD_PARAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lsis"),
         dictgen::InsensitiveStr::Ascii("lzed"),
@@ -81807,12 +81807,12 @@ pub static WORD_PARAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_PARAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAV_CHILDREN),
+static WORD_PARAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irtualiation"),
         dictgen::InsensitiveStr::Ascii("irtualied"),
@@ -81836,12 +81836,12 @@ pub static WORD_PARAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=13,
 };
 
-static WORD_PARAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAT_CHILDREN),
+static WORD_PARAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heses"),
         dictgen::InsensitiveStr::Ascii("mers"),
@@ -81850,12 +81850,12 @@ pub static WORD_PARAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PARAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAS_CHILDREN),
+static WORD_PARAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ide"),
@@ -81881,12 +81881,12 @@ pub static WORD_PARAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PARAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAR_CHILDREN),
+static WORD_PARAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agraph"),
         dictgen::InsensitiveStr::Ascii("aph"),
@@ -81912,12 +81912,12 @@ pub static WORD_PARAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_PARAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAP_CHILDREN),
+static WORD_PARAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hanalia"),
         dictgen::InsensitiveStr::Ascii("harse"),
@@ -81953,12 +81953,12 @@ pub static WORD_PARAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_PARAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAN_CHILDREN),
+static WORD_PARAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("eter"),
@@ -82004,12 +82004,12 @@ pub static WORD_PARAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PARAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PARAM_CHILDREN),
+static WORD_PARAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PARAM_CHILDREN),
     value: None,
 };
 
-static WORD_PARAM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PARAM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARAMA_NODE),
     None,
     None,
@@ -82038,12 +82038,12 @@ static WORD_PARAM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARAMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMT_CHILDREN),
+static WORD_PARAMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erer"),
@@ -82091,56 +82091,56 @@ pub static WORD_PARAMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_PARAMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMS_CHILDREN),
+static WORD_PARAMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["params"]],
     range: 1..=1,
 };
 
-static WORD_PARAMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMO_CHILDREN),
+static WORD_PARAMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rmal")],
     values: &[&["paranormal"]],
     range: 4..=4,
 };
 
-static WORD_PARAMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMN_CHILDREN),
+static WORD_PARAMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etrized")],
     values: &[&["parameterized"]],
     range: 7..=7,
 };
 
-static WORD_PARAMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMI_CHILDREN),
+static WORD_PARAMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ters")],
     values: &[&["parameters"]],
     range: 4..=4,
 };
 
-static WORD_PARAME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAME_CHILDREN),
+static WORD_PARAME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAME_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cias"),
         dictgen::InsensitiveStr::Ascii("dicks"),
@@ -82236,12 +82236,12 @@ pub static WORD_PARAME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_PARAMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMA_CHILDREN),
+static WORD_PARAMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dics"),
         dictgen::InsensitiveStr::Ascii("meter"),
@@ -82259,12 +82259,12 @@ pub static WORD_PARAMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PARAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAL_CHILDREN),
+static WORD_PARAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("elising"),
@@ -82336,23 +82336,23 @@ pub static WORD_PARAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_PARAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAI_CHILDREN),
+static WORD_PARAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ste")],
     values: &[&["parasite"]],
     range: 3..=3,
 };
 
-static WORD_PARAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAH_CHILDREN),
+static WORD_PARAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aps"),
         dictgen::InsensitiveStr::Ascii("prase"),
@@ -82361,12 +82361,12 @@ pub static WORD_PARAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_PARAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAG_CHILDREN),
+static WORD_PARAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aph"),
         dictgen::InsensitiveStr::Ascii("araph"),
@@ -82416,23 +82416,23 @@ pub static WORD_PARAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PARAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAF_CHILDREN),
+static WORD_PARAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("analia")],
     values: &[&["paraphernalia"]],
     range: 6..=6,
 };
 
-static WORD_PARAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAE_CHILDREN),
+static WORD_PARAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meter"),
         dictgen::InsensitiveStr::Ascii("meters"),
@@ -82448,12 +82448,12 @@ pub static WORD_PARAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PARAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAD_CHILDREN),
+static WORD_PARAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emics"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -82479,12 +82479,12 @@ pub static WORD_PARAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PARAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAC_CHILDREN),
+static WORD_PARAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hutage"),
         dictgen::InsensitiveStr::Ascii("hutte"),
@@ -82493,12 +82493,12 @@ pub static WORD_PARAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAP_CHILDREN),
+static WORD_PAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("anicalou"),
@@ -82508,12 +82508,12 @@ pub static WORD_PAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_PAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAO_CHILDREN),
+static WORD_PAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -82522,12 +82522,12 @@ pub static WORD_PAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_PAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAN_CHILDREN),
+static WORD_PAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asoic"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -82581,12 +82581,12 @@ pub static WORD_PAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_PAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAM_CHILDREN),
+static WORD_PAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("flet"),
         dictgen::InsensitiveStr::Ascii("plet"),
@@ -82595,12 +82595,12 @@ pub static WORD_PAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_PAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAL_CHILDREN),
+static WORD_PAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adines"),
         dictgen::InsensitiveStr::Ascii("adinlst"),
@@ -82730,12 +82730,12 @@ pub static WORD_PAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_PAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAK_CHILDREN),
+static WORD_PAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ageimpl"),
@@ -82773,12 +82773,12 @@ pub static WORD_PAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_PAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAI_CHILDREN),
+static WORD_PAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -82844,12 +82844,12 @@ pub static WORD_PAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAH_CHILDREN),
+static WORD_PAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntom"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -82867,12 +82867,12 @@ pub static WORD_PAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_PAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAG_CHILDREN),
+static WORD_PAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agraph"),
         dictgen::InsensitiveStr::Ascii("ckage"),
@@ -82894,23 +82894,23 @@ pub static WORD_PAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAF_CHILDREN),
+static WORD_PAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icist")],
     values: &[&["pacifist"]],
     range: 5..=5,
 };
 
-static WORD_PAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAE_CHILDREN),
+static WORD_PAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rmission"),
         dictgen::InsensitiveStr::Ascii("rmissions"),
@@ -82921,12 +82921,12 @@ pub static WORD_PAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAD_CHILDREN),
+static WORD_PAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -82944,12 +82944,12 @@ pub static WORD_PAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_PAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAC_CHILDREN),
+static WORD_PAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -83073,23 +83073,23 @@ pub static WORD_PAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_PAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAB_CHILDREN),
+static WORD_PAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("el")],
     values: &[&["panel"]],
     range: 2..=2,
 };
 
-static WORD_PAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAA_CHILDREN),
+static WORD_PAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckage"),
         dictgen::InsensitiveStr::Ascii("ckages"),
@@ -83100,12 +83100,12 @@ pub static WORD_PAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_O_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_O_CHILDREN),
+static WORD_O_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_O_CHILDREN),
     value: None,
 };
 
-static WORD_O_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_O_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OA_NODE),
     Some(&WORD_OB_NODE),
     Some(&WORD_OC_NODE),
@@ -83134,12 +83134,12 @@ static WORD_O_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OY_CHILDREN),
+static WORD_OY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OY_CHILDREN),
     value: None,
 };
 
-pub static WORD_OY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lmpic"),
         dictgen::InsensitiveStr::Ascii("lmpics"),
@@ -83149,12 +83149,12 @@ pub static WORD_OY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_OX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OX_CHILDREN),
+static WORD_OX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OX_CHILDREN),
     value: None,
 };
 
-pub static WORD_OX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igen"),
         dictgen::InsensitiveStr::Ascii("imoron"),
@@ -83164,12 +83164,12 @@ pub static WORD_OX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_OW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OW_CHILDREN),
+static WORD_OW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OW_CHILDREN),
     value: None,
 };
 
-pub static WORD_OW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ened"),
         dictgen::InsensitiveStr::Ascii("ener"),
@@ -83237,12 +83237,12 @@ pub static WORD_OW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_OV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OV_CHILDREN),
+static WORD_OV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OV_CHILDREN),
     value: None,
 };
 
-static WORD_OV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -83271,12 +83271,12 @@ static WORD_OV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OVV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVV_CHILDREN),
+static WORD_OVV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVV_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eride"),
         dictgen::InsensitiveStr::Ascii("erridden"),
@@ -83294,12 +83294,12 @@ pub static WORD_OVV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_OVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVS_CHILDREN),
+static WORD_OVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ervable"),
         dictgen::InsensitiveStr::Ascii("ervation"),
@@ -83317,12 +83317,12 @@ pub static WORD_OVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_OVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVR_CHILDREN),
+static WORD_OVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ide"),
         dictgen::InsensitiveStr::Ascii("ides"),
@@ -83342,12 +83342,12 @@ pub static WORD_OVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_OVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OVE_CHILDREN),
+static WORD_OVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OVE_CHILDREN),
     value: Some(&["oven", "over"]),
 };
 
-static WORD_OVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OVE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -83376,12 +83376,12 @@ static WORD_OVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OVEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVEW_CHILDREN),
+static WORD_OVEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ritable"),
         dictgen::InsensitiveStr::Ascii("rite"),
@@ -83401,12 +83401,12 @@ pub static WORD_OVEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_OVER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OVER_CHILDREN),
+static WORD_OVER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OVER_CHILDREN),
     value: None,
 };
 
-static WORD_OVER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OVER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OVERA_NODE),
     Some(&WORD_OVERB_NODE),
     Some(&WORD_OVERC_NODE),
@@ -83435,12 +83435,12 @@ static WORD_OVER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_OVERZ_NODE),
 ];
 
-static WORD_OVERZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERZ_CHILDREN),
+static WORD_OVERZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ealis"),
         dictgen::InsensitiveStr::Ascii("ealisly"),
@@ -83476,23 +83476,23 @@ pub static WORD_OVERZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_OVERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERY_CHILDREN),
+static WORD_OVERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERY_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hped")],
     values: &[&["overhyped"]],
     range: 4..=4,
 };
 
-static WORD_OVERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERW_CHILDREN),
+static WORD_OVERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ath"),
         dictgen::InsensitiveStr::Ascii("ealmed"),
@@ -83592,12 +83592,12 @@ pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_OVERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERV_CHILDREN),
+static WORD_OVERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ise"),
         dictgen::InsensitiveStr::Ascii("ize"),
@@ -83619,12 +83619,12 @@ pub static WORD_OVERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_OVERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERU_CHILDREN),
+static WORD_OVERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("les"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -83633,12 +83633,12 @@ pub static WORD_OVERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_OVERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERT_CHILDREN),
+static WORD_OVERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apping"),
         dictgen::InsensitiveStr::Ascii("hining"),
@@ -83660,12 +83660,12 @@ pub static WORD_OVERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_OVERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERS_CHILDREN),
+static WORD_OVERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emplification"),
         dictgen::InsensitiveStr::Ascii("etimating"),
@@ -83721,12 +83721,12 @@ pub static WORD_OVERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=14,
 };
 
-static WORD_OVERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERR_CHILDREN),
+static WORD_OVERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ading"),
         dictgen::InsensitiveStr::Ascii("dies"),
@@ -83810,12 +83810,12 @@ pub static WORD_OVERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_OVERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERP_CHILDREN),
+static WORD_OVERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aied"),
@@ -83851,34 +83851,34 @@ pub static WORD_OVERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OVERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERN_CHILDREN),
+static WORD_OVERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("urfed")],
     values: &[&["overturned"]],
     range: 5..=5,
 };
 
-static WORD_OVERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERM_CHILDREN),
+static WORD_OVERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("apping")],
     values: &[&["overlapping"]],
     range: 6..=6,
 };
 
-static WORD_OVERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERL_CHILDREN),
+static WORD_OVERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anded"),
         dictgen::InsensitiveStr::Ascii("aod"),
@@ -83960,12 +83960,12 @@ pub static WORD_OVERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_OVERK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERK_CHILDREN),
+static WORD_OVERK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERK_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apping"),
         dictgen::InsensitiveStr::Ascii("locked"),
@@ -83974,12 +83974,12 @@ pub static WORD_OVERK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_OVERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERI_CHILDREN),
+static WORD_OVERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ddden"),
         dictgen::InsensitiveStr::Ascii("dden"),
@@ -84003,12 +84003,12 @@ pub static WORD_OVERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_OVERH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERH_CHILDREN),
+static WORD_OVERH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("eading"),
@@ -84050,12 +84050,12 @@ pub static WORD_OVERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OVERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERF_CHILDREN),
+static WORD_OVERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apping"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -84079,12 +84079,12 @@ pub static WORD_OVERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_OVERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERE_CHILDREN),
+static WORD_OVERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aching"),
         dictgen::InsensitiveStr::Ascii("ngeneer"),
@@ -84104,12 +84104,12 @@ pub static WORD_OVERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=10,
 };
 
-static WORD_OVERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERD_CHILDREN),
+static WORD_OVERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irve"),
         dictgen::InsensitiveStr::Ascii("rev"),
@@ -84118,12 +84118,12 @@ pub static WORD_OVERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_OVERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERC_CHILDREN),
+static WORD_OVERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apping"),
         dictgen::InsensitiveStr::Ascii("haring"),
@@ -84185,12 +84185,12 @@ pub static WORD_OVERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_OVERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERB_CHILDREN),
+static WORD_OVERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aord"),
         dictgen::InsensitiveStr::Ascii("earring"),
@@ -84208,12 +84208,12 @@ pub static WORD_OVERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_OVERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERA_CHILDREN),
+static WORD_OVERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -84231,12 +84231,12 @@ pub static WORD_OVERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_OVEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVEL_CHILDREN),
+static WORD_OVEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ap"),
         dictgen::InsensitiveStr::Ascii("apping"),
@@ -84245,12 +84245,12 @@ pub static WORD_OVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_OVEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVEF_CHILDREN),
+static WORD_OVEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("low"),
         dictgen::InsensitiveStr::Ascii("lowed"),
@@ -84266,23 +84266,23 @@ pub static WORD_OVEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_OVEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVEE_CHILDREN),
+static WORD_OVEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("run")],
     values: &[&["overrun"]],
     range: 3..=3,
 };
 
-static WORD_OU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OU_CHILDREN),
+static WORD_OU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OU_CHILDREN),
     value: None,
 };
 
-static WORD_OU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_OUB_NODE),
     None,
@@ -84311,12 +84311,12 @@ static WORD_OU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUU_CHILDREN),
+static WORD_OUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -84325,12 +84325,12 @@ pub static WORD_OUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_OUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OUT_CHILDREN),
+static WORD_OUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OUT_CHILDREN),
     value: None,
 };
 
-static WORD_OUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OUT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OUTA_NODE),
     Some(&WORD_OUTB_NODE),
     Some(&WORD_OUTC_NODE),
@@ -84359,12 +84359,12 @@ static WORD_OUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OUTW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTW_CHILDREN),
+static WORD_OUTW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTW_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eighes"),
         dictgen::InsensitiveStr::Ascii("eight"),
@@ -84380,12 +84380,12 @@ pub static WORD_OUTW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_OUTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTU_CHILDREN),
+static WORD_OUTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pts"),
@@ -84403,12 +84403,12 @@ pub static WORD_OUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_OUTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTT_CHILDREN),
+static WORD_OUTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ermost"),
@@ -84417,12 +84417,12 @@ pub static WORD_OUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_OUTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTS_CHILDREN),
+static WORD_OUTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elves"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -84458,12 +84458,12 @@ pub static WORD_OUTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_OUTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTR_CHILDREN),
+static WORD_OUTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aegously"),
         dictgen::InsensitiveStr::Ascii("ageos"),
@@ -84499,12 +84499,12 @@ pub static WORD_OUTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_OUTP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTP_CHILDREN),
+static WORD_OUTP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alyed"),
         dictgen::InsensitiveStr::Ascii("erfoem"),
@@ -84560,12 +84560,12 @@ pub static WORD_OUTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OUTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTO_CHILDREN),
+static WORD_OUTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ign"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -84579,12 +84579,12 @@ pub static WORD_OUTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_OUTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTN_CHILDREN),
+static WORD_OUTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("umbed"),
         dictgen::InsensitiveStr::Ascii("umberd"),
@@ -84600,12 +84600,12 @@ pub static WORD_OUTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_OUTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTL_CHILDREN),
+static WORD_OUTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cassed"),
         dictgen::InsensitiveStr::Ascii("look"),
@@ -84614,12 +84614,12 @@ pub static WORD_OUTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_OUTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTI_CHILDREN),
+static WORD_OUTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sde"),
         dictgen::InsensitiveStr::Ascii("sder"),
@@ -84629,34 +84629,34 @@ pub static WORD_OUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_OUTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTH_CHILDREN),
+static WORD_OUTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["other", "outer"]],
     range: 2..=2,
 };
 
-static WORD_OUTG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTG_CHILDREN),
+static WORD_OUTG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTG_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oign")],
     values: &[&["outgoing"]],
     range: 4..=4,
 };
 
-static WORD_OUTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTF_CHILDREN),
+static WORD_OUTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eild"),
         dictgen::InsensitiveStr::Ascii("idel"),
@@ -84667,12 +84667,12 @@ pub static WORD_OUTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_OUTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTC_CHILDREN),
+static WORD_OUTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alssed"),
         dictgen::InsensitiveStr::Ascii("lasssed"),
@@ -84681,12 +84681,12 @@ pub static WORD_OUTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_OUTB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTB_CHILDREN),
+static WORD_OUTB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTB_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ut"),
         dictgen::InsensitiveStr::Ascii("uts"),
@@ -84695,23 +84695,23 @@ pub static WORD_OUTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_OUTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTA_CHILDREN),
+static WORD_OUTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dted")],
     values: &[&["outdated"]],
     range: 4..=4,
 };
 
-static WORD_OUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUS_CHILDREN),
+static WORD_OUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ide"),
         dictgen::InsensitiveStr::Ascii("tanding"),
@@ -84731,12 +84731,12 @@ pub static WORD_OUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_OUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUR_CHILDREN),
+static WORD_OUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("selfe"),
         dictgen::InsensitiveStr::Ascii("selfes"),
@@ -84758,12 +84758,12 @@ pub static WORD_OUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_OUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUP_CHILDREN),
+static WORD_OUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tut"),
         dictgen::InsensitiveStr::Ascii("tuted"),
@@ -84789,23 +84789,23 @@ pub static WORD_OUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_OUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUN_CHILDREN),
+static WORD_OUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tline")],
     values: &[&["outline"]],
     range: 5..=5,
 };
 
-static WORD_OUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUL_CHILDREN),
+static WORD_OUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tinenodes"),
         dictgen::InsensitiveStr::Ascii("tiner"),
@@ -84821,12 +84821,12 @@ pub static WORD_OUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_OUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUE_CHILDREN),
+static WORD_OUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ue"),
@@ -84836,23 +84836,23 @@ pub static WORD_OUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_OUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUB_CHILDREN),
+static WORD_OUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lisher")],
     values: &[&["publisher"]],
     range: 6..=6,
 };
 
-static WORD_OT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OT_CHILDREN),
+static WORD_OT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OT_CHILDREN),
     value: Some(&["to", "of", "or", "not"]),
 };
 
-static WORD_OT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OTA_NODE),
     None,
     None,
@@ -84881,34 +84881,34 @@ static WORD_OT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTU_CHILDREN),
+static WORD_OTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTU_CHILDREN),
     value: Some(&["out"]),
 };
 
-pub static WORD_OTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("put")],
     values: &[&["output"]],
     range: 3..=3,
 };
 
-static WORD_OTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTR_CHILDREN),
+static WORD_OTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hographic")],
     values: &[&["orthographic"]],
     range: 9..=9,
 };
 
-static WORD_OTP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTP_CHILDREN),
+static WORD_OTP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -84919,12 +84919,12 @@ pub static WORD_OTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_OTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTI_CHILDREN),
+static WORD_OTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fication"),
         dictgen::InsensitiveStr::Ascii("fications"),
@@ -84948,12 +84948,12 @@ pub static WORD_OTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_OTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTH_CHILDREN),
+static WORD_OTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ere"),
@@ -85045,12 +85045,12 @@ pub static WORD_OTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_OTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTE_CHILDREN),
+static WORD_OTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hr"),
         dictgen::InsensitiveStr::Ascii("hrwice"),
@@ -85074,12 +85074,12 @@ pub static WORD_OTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_OTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTA_CHILDREN),
+static WORD_OTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -85105,12 +85105,12 @@ pub static WORD_OTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_OS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OS_CHILDREN),
+static WORD_OS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bidian"),
         dictgen::InsensitiveStr::Ascii("bscure"),
@@ -85188,12 +85188,12 @@ pub static WORD_OS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_OR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OR_CHILDREN),
+static WORD_OR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OR_CHILDREN),
     value: None,
 };
 
-static WORD_OR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORA_NODE),
     Some(&WORD_ORB_NODE),
     Some(&WORD_ORC_NODE),
@@ -85222,23 +85222,23 @@ static WORD_OR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ORU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORU_CHILDREN),
+static WORD_ORU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORU_CHILDREN),
     value: Some(&["our"]),
 };
 
-pub static WORD_ORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORT_CHILDREN),
+static WORD_ORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hagnal"),
         dictgen::InsensitiveStr::Ascii("hagonal"),
@@ -85274,23 +85274,23 @@ pub static WORD_ORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=14,
 };
 
-static WORD_ORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORR_CHILDREN),
+static WORD_ORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iginal")],
     values: &[&["original"]],
     range: 6..=6,
 };
 
-static WORD_ORP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORP_CHILDREN),
+static WORD_ORP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahns"),
         dictgen::InsensitiveStr::Ascii("an"),
@@ -85312,23 +85312,23 @@ pub static WORD_ORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ORL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORL_CHILDREN),
+static WORD_ORL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enas")],
     values: &[&["orleans"]],
     range: 4..=4,
 };
 
-static WORD_ORK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORK_CHILDREN),
+static WORD_ORK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("id"),
         dictgen::InsensitiveStr::Ascii("ids"),
@@ -85337,12 +85337,12 @@ pub static WORD_ORK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_ORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ORI_CHILDREN),
+static WORD_ORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ORI_CHILDREN),
     value: None,
 };
 
-static WORD_ORI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ORI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORIA_NODE),
     Some(&WORD_ORIB_NODE),
     Some(&WORD_ORIC_NODE),
@@ -85371,23 +85371,23 @@ static WORD_ORI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ORIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIT_CHILDREN),
+static WORD_ORIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inal")],
     values: &[&["original"]],
     range: 4..=4,
 };
 
-static WORD_ORIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIN_CHILDREN),
+static WORD_ORIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gal"),
         dictgen::InsensitiveStr::Ascii("gally"),
@@ -85397,23 +85397,23 @@ pub static WORD_ORIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ORII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORII_CHILDREN),
+static WORD_ORII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORII_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gn")],
     values: &[&["origin"]],
     range: 2..=2,
 };
 
-static WORD_ORIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIG_CHILDREN),
+static WORD_ORIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("analy"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -85533,12 +85533,12 @@ pub static WORD_ORIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ORIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIE_CHILDREN),
+static WORD_ORIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -85586,12 +85586,12 @@ pub static WORD_ORIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ORID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORID_CHILDREN),
+static WORD_ORID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORID_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inal"),
         dictgen::InsensitiveStr::Ascii("inals"),
@@ -85609,12 +85609,12 @@ pub static WORD_ORID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ORIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIC_CHILDREN),
+static WORD_ORIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("les"),
@@ -85623,23 +85623,23 @@ pub static WORD_ORIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_ORIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIB_CHILDREN),
+static WORD_ORIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tal")],
     values: &[&["orbital"]],
     range: 3..=3,
 };
 
-static WORD_ORIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIA_CHILDREN),
+static WORD_ORIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("ntate"),
@@ -85655,12 +85655,12 @@ pub static WORD_ORIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORH_CHILDREN),
+static WORD_ORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cestra"),
         dictgen::InsensitiveStr::Ascii("pan"),
@@ -85682,12 +85682,12 @@ pub static WORD_ORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ORG_CHILDREN),
+static WORD_ORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ORG_CHILDREN),
     value: None,
 };
 
-static WORD_ORG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ORG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORGA_NODE),
     None,
     None,
@@ -85716,12 +85716,12 @@ static WORD_ORG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ORGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGN_CHILDREN),
+static WORD_ORGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aisation"),
         dictgen::InsensitiveStr::Ascii("aised"),
@@ -85731,12 +85731,12 @@ pub static WORD_ORGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ORGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGI_CHILDREN),
+static WORD_ORGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ginal"),
         dictgen::InsensitiveStr::Ascii("ginally"),
@@ -85814,12 +85814,12 @@ pub static WORD_ORGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_ORGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ORGA_CHILDREN),
+static WORD_ORGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ORGA_CHILDREN),
     value: None,
 };
 
-static WORD_ORGA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ORGA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -85848,12 +85848,12 @@ static WORD_ORGA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ORGAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGAS_CHILDREN),
+static WORD_ORGAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mes"),
         dictgen::InsensitiveStr::Ascii("mos"),
@@ -85863,12 +85863,12 @@ pub static WORD_ORGAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_ORGAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ORGAN_CHILDREN),
+static WORD_ORGAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ORGAN_CHILDREN),
     value: None,
 };
 
-static WORD_ORGAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ORGAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORGANA_NODE),
     None,
     None,
@@ -85897,12 +85897,12 @@ static WORD_ORGAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORGANZ_NODE),
 ];
 
-static WORD_ORGANZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANZ_CHILDREN),
+static WORD_ORGANZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("iation"),
@@ -85932,12 +85932,12 @@ pub static WORD_ORGANZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_ORGANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANS_CHILDREN),
+static WORD_ORGANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iation"),
         dictgen::InsensitiveStr::Ascii("iations"),
@@ -85965,12 +85965,12 @@ pub static WORD_ORGANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_ORGANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANI_CHILDREN),
+static WORD_ORGANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caly"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -86096,12 +86096,12 @@ pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_ORGANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANE_CHILDREN),
+static WORD_ORGANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("red"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -86110,34 +86110,34 @@ pub static WORD_ORGANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_ORGANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANA_CHILDREN),
+static WORD_ORGANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ize")],
     values: &[&["organize"]],
     range: 3..=3,
 };
 
-static WORD_ORGAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGAM_CHILDREN),
+static WORD_ORGAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ise")],
     values: &[&["organise"]],
     range: 3..=3,
 };
 
-static WORD_ORGAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGAI_CHILDREN),
+static WORD_ORGAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nizing"),
         dictgen::InsensitiveStr::Ascii("nsation"),
@@ -86159,23 +86159,23 @@ pub static WORD_ORGAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORF_CHILDREN),
+static WORD_ORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["offer", "order"]],
     range: 2..=2,
 };
 
-static WORD_ORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORE_CHILDREN),
+static WORD_ORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -86207,12 +86207,12 @@ pub static WORD_ORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORD_CHILDREN),
+static WORD_ORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("erd"),
@@ -86238,12 +86238,12 @@ pub static WORD_ORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORC_CHILDREN),
+static WORD_ORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -86287,23 +86287,23 @@ pub static WORD_ORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ORB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORB_CHILDREN),
+static WORD_ORB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tial")],
     values: &[&["orbital"]],
     range: 4..=4,
 };
 
-static WORD_ORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORA_CHILDREN),
+static WORD_ORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cels"),
         dictgen::InsensitiveStr::Ascii("gnered"),
@@ -86339,12 +86339,12 @@ pub static WORD_ORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_OP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OP_CHILDREN),
+static WORD_OP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OP_CHILDREN),
     value: None,
 };
 
-static WORD_OP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OPA_NODE),
     Some(&WORD_OPB_NODE),
     None,
@@ -86373,12 +86373,12 @@ static WORD_OP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPY_CHILDREN),
+static WORD_OPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPY_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -86387,12 +86387,12 @@ pub static WORD_OPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_OPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPU_CHILDREN),
+static WORD_OPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("late"),
         dictgen::InsensitiveStr::Ascii("lates"),
@@ -86406,12 +86406,12 @@ pub static WORD_OPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_OPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OPT_CHILDREN),
+static WORD_OPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OPT_CHILDREN),
     value: None,
 };
 
-static WORD_OPT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OPT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OPTA_NODE),
     None,
     None,
@@ -86440,12 +86440,12 @@ static WORD_OPT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OPTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTO_CHILDREN),
+static WORD_OPTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("inal"),
@@ -86471,12 +86471,12 @@ pub static WORD_OPTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_OPTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTM_CHILDREN),
+static WORD_OPTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isation"),
         dictgen::InsensitiveStr::Ascii("isations"),
@@ -86496,12 +86496,12 @@ pub static WORD_OPTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_OPTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OPTI_CHILDREN),
+static WORD_OPTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OPTI_CHILDREN),
     value: None,
 };
 
-static WORD_OPTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OPTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -86530,34 +86530,34 @@ static WORD_OPTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_OPTIZ_NODE),
 ];
 
-static WORD_OPTIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIZ_CHILDREN),
+static WORD_OPTIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mied")],
     values: &[&["optimized"]],
     range: 4..=4,
 };
 
-static WORD_OPTIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIS_CHILDREN),
+static WORD_OPTIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mied")],
     values: &[&["optimised"]],
     range: 4..=4,
 };
 
-static WORD_OPTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIO_CHILDREN),
+static WORD_OPTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIO_CHILDREN),
     value: Some(&["option"]),
 };
 
-pub static WORD_OPTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anl"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -86603,12 +86603,12 @@ pub static WORD_OPTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_OPTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIN_CHILDREN),
+static WORD_OPTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIN_CHILDREN),
     value: Some(&["option"]),
 };
 
-pub static WORD_OPTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -86618,12 +86618,12 @@ pub static WORD_OPTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_OPTIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIM_CHILDREN),
+static WORD_OPTIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aal"),
         dictgen::InsensitiveStr::Ascii("asation"),
@@ -86727,23 +86727,23 @@ pub static WORD_OPTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OPTII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTII_CHILDREN),
+static WORD_OPTII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTII_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onal")],
     values: &[&["optional"]],
     range: 4..=4,
 };
 
-static WORD_OPTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTH_CHILDREN),
+static WORD_OPTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("almic"),
         dictgen::InsensitiveStr::Ascii("almologist"),
@@ -86759,12 +86759,12 @@ pub static WORD_OPTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_OPTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTE_CHILDREN),
+static WORD_OPTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ning"),
@@ -86774,12 +86774,12 @@ pub static WORD_OPTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_OPTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTA_CHILDREN),
+static WORD_OPTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -86790,12 +86790,12 @@ pub static WORD_OPTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_OPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPR_CHILDREN),
+static WORD_OPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -86841,12 +86841,12 @@ pub static WORD_OPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_OPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OPP_CHILDREN),
+static WORD_OPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OPP_CHILDREN),
     value: None,
 };
 
-static WORD_OPP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OPP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -86875,12 +86875,12 @@ static WORD_OPP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OPPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPU_CHILDREN),
+static WORD_OPPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rtinity"),
         dictgen::InsensitiveStr::Ascii("rtunites"),
@@ -86898,23 +86898,23 @@ pub static WORD_OPPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_OPPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPS_CHILDREN),
+static WORD_OPPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPS_CHILDREN),
     value: Some(&["oops"]),
 };
 
-pub static WORD_OPPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ofite")],
     values: &[&["opposite"]],
     range: 5..=5,
 };
 
-static WORD_OPPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPR_CHILDREN),
+static WORD_OPPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essin"),
         dictgen::InsensitiveStr::Ascii("essiun"),
@@ -86940,12 +86940,12 @@ pub static WORD_OPPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_OPPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPP_CHILDREN),
+static WORD_OPPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onent"),
         dictgen::InsensitiveStr::Ascii("ortunity"),
@@ -86955,12 +86955,12 @@ pub static WORD_OPPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_OPPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPO_CHILDREN),
+static WORD_OPPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nant"),
         dictgen::InsensitiveStr::Ascii("nenet"),
@@ -87032,12 +87032,12 @@ pub static WORD_OPPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_OPPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPI_CHILDREN),
+static WORD_OPPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nion"),
         dictgen::InsensitiveStr::Ascii("nions"),
@@ -87047,12 +87047,12 @@ pub static WORD_OPPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_OPPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPE_CHILDREN),
+static WORD_OPPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nly"),
         dictgen::InsensitiveStr::Ascii("rand"),
@@ -87084,12 +87084,12 @@ pub static WORD_OPPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_OPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPO_CHILDREN),
+static WORD_OPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -87117,12 +87117,12 @@ pub static WORD_OPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_OPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPN_CHILDREN),
+static WORD_OPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -87140,12 +87140,12 @@ pub static WORD_OPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_OPJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPJ_CHILDREN),
+static WORD_OPJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -87177,12 +87177,12 @@ pub static WORD_OPJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_OPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPI_CHILDREN),
+static WORD_OPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("misation"),
         dictgen::InsensitiveStr::Ascii("mized"),
@@ -87260,12 +87260,12 @@ pub static WORD_OPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_OPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPH_CHILDREN),
+static WORD_OPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("talmology"),
@@ -87274,23 +87274,23 @@ pub static WORD_OPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_OPF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPF_CHILDREN),
+static WORD_OPF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPF_CHILDREN),
     value: Some(&["of"]),
 };
 
-pub static WORD_OPF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_OPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OPE_CHILDREN),
+static WORD_OPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OPE_CHILDREN),
     value: None,
 };
 
-static WORD_OPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OPEA_NODE),
     None,
     None,
@@ -87319,12 +87319,12 @@ static WORD_OPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPET_CHILDREN),
+static WORD_OPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -87333,12 +87333,12 @@ pub static WORD_OPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_OPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPER_CHILDREN),
+static WORD_OPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aand"),
         dictgen::InsensitiveStr::Ascii("aands"),
@@ -87448,12 +87448,12 @@ pub static WORD_OPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_OPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEN_CHILDREN),
+static WORD_OPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apig"),
         dictgen::InsensitiveStr::Ascii("brower"),
@@ -87495,12 +87495,12 @@ pub static WORD_OPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_OPEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEM_CHILDREN),
+static WORD_OPEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEM_CHILDREN),
     value: Some(&["open"]),
 };
 
-pub static WORD_OPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ess"),
@@ -87511,12 +87511,12 @@ pub static WORD_OPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_OPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEI_CHILDREN),
+static WORD_OPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("nging"),
@@ -87526,23 +87526,23 @@ pub static WORD_OPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_OPEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEG_CHILDREN),
+static WORD_OPEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEG_CHILDREN),
     value: Some(&["open"]),
 };
 
-pub static WORD_OPEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["opening"]],
     range: 3..=3,
 };
 
-static WORD_OPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEA_CHILDREN),
+static WORD_OPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("arations"),
@@ -87636,12 +87636,12 @@ pub static WORD_OPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPB_CHILDREN),
+static WORD_OPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ject"),
         dictgen::InsensitiveStr::Ascii("jective"),
@@ -87651,12 +87651,12 @@ pub static WORD_OPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_OPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPA_CHILDREN),
+static WORD_OPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctity"),
         dictgen::InsensitiveStr::Ascii("ctiy"),
@@ -87684,12 +87684,12 @@ pub static WORD_OPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_OO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OO_CHILDREN),
+static WORD_OO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mmits"),
         dictgen::InsensitiveStr::Ascii("ur"),
@@ -87701,12 +87701,12 @@ pub static WORD_OO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ON_CHILDREN),
+static WORD_ON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ON_CHILDREN),
     value: None,
 };
 
-static WORD_ON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ONA_NODE),
     Some(&WORD_ONB_NODE),
     Some(&WORD_ONC_NODE),
@@ -87735,23 +87735,23 @@ static WORD_ON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ONY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONY_CHILDREN),
+static WORD_ONY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONY_CHILDREN),
     value: Some(&["only", "on", "one"]),
 };
 
-pub static WORD_ONY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["only"]],
     range: 1..=1,
 };
 
-static WORD_ONW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONW_CHILDREN),
+static WORD_ONW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONW_CHILDREN),
     value: Some(&["own", "now"]),
 };
 
-pub static WORD_ONW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ee"),
@@ -87771,12 +87771,12 @@ pub static WORD_ONW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ONV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONV_CHILDREN),
+static WORD_ONV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eience"),
         dictgen::InsensitiveStr::Ascii("eniently"),
@@ -87786,12 +87786,12 @@ pub static WORD_ONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=8,
 };
 
-static WORD_ONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONT_CHILDREN),
+static WORD_ONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ained"),
@@ -87825,12 +87825,12 @@ pub static WORD_ONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_ONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONS_CHILDREN),
+static WORD_ONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alught"),
         dictgen::InsensitiveStr::Ascii("elf"),
@@ -87850,12 +87850,12 @@ pub static WORD_ONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ONO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONO_CHILDREN),
+static WORD_ONO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONO_CHILDREN),
     value: Some(&["one"]),
 };
 
-pub static WORD_ONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ly"),
         dictgen::InsensitiveStr::Ascii("manopea"),
@@ -87875,23 +87875,23 @@ pub static WORD_ONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONN_CHILDREN),
+static WORD_ONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONN_CHILDREN),
     value: Some(&["on"]),
 };
 
-pub static WORD_ONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ONM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONM_CHILDREN),
+static WORD_ONM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipotent"),
         dictgen::InsensitiveStr::Ascii("iscient"),
@@ -87915,12 +87915,12 @@ pub static WORD_ONM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=9,
 };
 
-static WORD_ONL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONL_CHILDREN),
+static WORD_ONL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONL_CHILDREN),
     value: Some(&["only"]),
 };
 
-pub static WORD_ONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("iene"),
@@ -87942,12 +87942,12 @@ pub static WORD_ONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONG_CHILDREN),
+static WORD_ONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ewild"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -87957,23 +87957,23 @@ pub static WORD_ONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONF_CHILDREN),
+static WORD_ONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("igure")],
     values: &[&["configure"]],
     range: 5..=5,
 };
 
-static WORD_ONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONE_CHILDREN),
+static WORD_ONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("f"),
@@ -87983,23 +87983,23 @@ pub static WORD_ONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_OND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OND_CHILDREN),
+static WORD_OND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OND_CHILDREN),
     value: Some(&["one", "and"]),
 };
 
-pub static WORD_OND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONC_CHILDREN),
+static WORD_ONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("hage"),
@@ -88008,12 +88008,12 @@ pub static WORD_ONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ONB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONB_CHILDREN),
+static WORD_ONB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aord"),
         dictgen::InsensitiveStr::Ascii("orad"),
@@ -88022,23 +88022,23 @@ pub static WORD_ONB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_ONA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONA_CHILDREN),
+static WORD_ONA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("trio")],
     values: &[&["ontario"]],
     range: 4..=4,
 };
 
-static WORD_OM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OM_CHILDREN),
+static WORD_OM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -88158,12 +88158,12 @@ pub static WORD_OM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_OL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OL_CHILDREN),
+static WORD_OL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bigatory"),
         dictgen::InsensitiveStr::Ascii("biterated"),
@@ -88207,12 +88207,12 @@ pub static WORD_OL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_OK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OK_CHILDREN),
+static WORD_OK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OK_CHILDREN),
     value: None,
 };
 
-pub static WORD_OK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("tober"),
@@ -88221,12 +88221,12 @@ pub static WORD_OK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_OJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OJ_CHILDREN),
+static WORD_OJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bect"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -88248,12 +88248,12 @@ pub static WORD_OJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_OI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OI_CHILDREN),
+static WORD_OI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("gin"),
@@ -88281,12 +88281,12 @@ pub static WORD_OI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_OH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OH_CHILDREN),
+static WORD_OH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erwise"),
@@ -88306,12 +88306,12 @@ pub static WORD_OH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_OG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OG_CHILDREN),
+static WORD_OG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OG_CHILDREN),
     value: None,
 };
 
-pub static WORD_OG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anization"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -88335,12 +88335,12 @@ pub static WORD_OG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_OF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OF_CHILDREN),
+static WORD_OF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OF_CHILDREN),
     value: None,
 };
 
-static WORD_OF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_OFC_NODE),
@@ -88369,23 +88369,23 @@ static WORD_OF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFU_CHILDREN),
+static WORD_OFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("scated")],
     values: &[&["obfuscated"]],
     range: 6..=6,
 };
 
-static WORD_OFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFT_CHILDREN),
+static WORD_OFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enly"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -88401,12 +88401,12 @@ pub static WORD_OFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_OFS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFS_CHILDREN),
+static WORD_OFS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etted"),
@@ -88416,12 +88416,12 @@ pub static WORD_OFS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_OFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFR_CHILDREN),
+static WORD_OFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFR_CHILDREN),
     value: Some(&["for"]),
 };
 
-pub static WORD_OFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("om"),
         dictgen::InsensitiveStr::Ascii("ward"),
@@ -88430,23 +88430,23 @@ pub static WORD_OFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_OFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFO_CHILDREN),
+static WORD_OFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFO_CHILDREN),
     value: Some(&["of"]),
 };
 
-pub static WORD_OFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("curse")],
     values: &[&["ofcourse"]],
     range: 5..=5,
 };
 
-static WORD_OFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFI_CHILDREN),
+static WORD_OFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cial"),
@@ -88476,12 +88476,12 @@ pub static WORD_OFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_OFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OFF_CHILDREN),
+static WORD_OFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OFF_CHILDREN),
     value: None,
 };
 
-static WORD_OFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OFF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OFFA_NODE),
     None,
     Some(&WORD_OFFC_NODE),
@@ -88510,34 +88510,34 @@ static WORD_OFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OFFX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFX_CHILDREN),
+static WORD_OFFX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFX_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["offset"]],
     range: 2..=2,
 };
 
-static WORD_OFFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFT_CHILDREN),
+static WORD_OFFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("en")],
     values: &[&["often"]],
     range: 2..=2,
 };
 
-static WORD_OFFS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFS_CHILDREN),
+static WORD_OFFS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ense"),
@@ -88575,34 +88575,34 @@ pub static WORD_OFFS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_OFFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFR_CHILDREN),
+static WORD_OFFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["offered"]],
     range: 2..=2,
 };
 
-static WORD_OFFP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFP_CHILDREN),
+static WORD_OFFP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sring")],
     values: &[&["offspring"]],
     range: 5..=5,
 };
 
-static WORD_OFFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFL_CHILDREN),
+static WORD_OFFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aod"),
         dictgen::InsensitiveStr::Ascii("aoded"),
@@ -88618,12 +88618,12 @@ pub static WORD_OFFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_OFFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFI_CHILDREN),
+static WORD_OFFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cail"),
@@ -88675,12 +88675,12 @@ pub static WORD_OFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_OFFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFF_CHILDREN),
+static WORD_OFFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ences"),
@@ -88700,12 +88700,12 @@ pub static WORD_OFFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_OFFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFE_CHILDREN),
+static WORD_OFFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ner"),
@@ -88747,12 +88747,12 @@ pub static WORD_OFFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_OFFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFC_CHILDREN),
+static WORD_OFFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -88770,34 +88770,34 @@ pub static WORD_OFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_OFFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFA_CHILDREN),
+static WORD_OFFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["offset"]],
     range: 2..=2,
 };
 
-static WORD_OFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFE_CHILDREN),
+static WORD_OFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["offer"]],
     range: 1..=1,
 };
 
-static WORD_OFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFC_CHILDREN),
+static WORD_OFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oruse"),
         dictgen::InsensitiveStr::Ascii("oure"),
@@ -88815,12 +88815,12 @@ pub static WORD_OFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_OE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OE_CHILDREN),
+static WORD_OE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("pnapi"),
@@ -88846,12 +88846,12 @@ pub static WORD_OE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_OD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OD_CHILDREN),
+static WORD_OD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OD_CHILDREN),
     value: None,
 };
 
-pub static WORD_OD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asee"),
         dictgen::InsensitiveStr::Ascii("asees"),
@@ -88873,12 +88873,12 @@ pub static WORD_OD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_OC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OC_CHILDREN),
+static WORD_OC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OC_CHILDREN),
     value: None,
 };
 
-static WORD_OC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OCA_NODE),
     None,
     Some(&WORD_OCC_NODE),
@@ -88907,12 +88907,12 @@ static WORD_OC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCU_CHILDREN),
+static WORD_OCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("ntries"),
@@ -88956,12 +88956,12 @@ pub static WORD_OCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_OCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCT_CHILDREN),
+static WORD_OCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -88989,23 +88989,23 @@ pub static WORD_OCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_OCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCR_CHILDREN),
+static WORD_OCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aina")],
     values: &[&["ocarina"]],
     range: 4..=4,
 };
 
-static WORD_OCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCO_CHILDREN),
+static WORD_OCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rrence"),
         dictgen::InsensitiveStr::Ascii("rrences"),
@@ -89021,12 +89021,12 @@ pub static WORD_OCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_OCN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCN_CHILDREN),
+static WORD_OCN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("figuration"),
@@ -89036,12 +89036,12 @@ pub static WORD_OCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_OCM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCM_CHILDREN),
+static WORD_OCM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pared"),
         dictgen::InsensitiveStr::Ascii("puted"),
@@ -89050,23 +89050,23 @@ pub static WORD_OCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_OCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCL_CHILDREN),
+static WORD_OCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uded")],
     values: &[&["occluded"]],
     range: 4..=4,
 };
 
-static WORD_OCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCI_CHILDREN),
+static WORD_OCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("late"),
         dictgen::InsensitiveStr::Ascii("lated"),
@@ -89090,34 +89090,34 @@ pub static WORD_OCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_OCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCH_CHILDREN),
+static WORD_OCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("estrating")],
     values: &[&["orchestrating"]],
     range: 9..=9,
 };
 
-static WORD_OCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCE_CHILDREN),
+static WORD_OCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCE_CHILDREN),
     value: Some(&["once", "one", "ore"]),
 };
 
-pub static WORD_OCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_OCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OCC_CHILDREN),
+static WORD_OCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OCC_CHILDREN),
     value: None,
 };
 
-static WORD_OCC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OCC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OCCA_NODE),
     None,
     Some(&WORD_OCCC_NODE),
@@ -89146,12 +89146,12 @@ static WORD_OCC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OCCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCU_CHILDREN),
+static WORD_OCCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cence"),
         dictgen::InsensitiveStr::Ascii("cences"),
@@ -89217,23 +89217,23 @@ pub static WORD_OCCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_OCCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCS_CHILDREN),
+static WORD_OCCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ionally")],
     values: &[&["occasionally"]],
     range: 7..=7,
 };
 
-static WORD_OCCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCR_CHILDREN),
+static WORD_OCCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rance"),
         dictgen::InsensitiveStr::Ascii("rances"),
@@ -89251,12 +89251,12 @@ pub static WORD_OCCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_OCCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCO_CHILDREN),
+static WORD_OCCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rding"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -89278,12 +89278,12 @@ pub static WORD_OCCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_OCCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCC_CHILDREN),
+static WORD_OCCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ur"),
         dictgen::InsensitiveStr::Ascii("ured"),
@@ -89294,12 +89294,12 @@ pub static WORD_OCCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_OCCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCA_CHILDREN),
+static WORD_OCCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isionally"),
         dictgen::InsensitiveStr::Ascii("ison"),
@@ -89353,12 +89353,12 @@ pub static WORD_OCCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_OCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCA_CHILDREN),
+static WORD_OCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rnia"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -89394,12 +89394,12 @@ pub static WORD_OCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_OB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OB_CHILDREN),
+static WORD_OB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OB_CHILDREN),
     value: None,
 };
 
-static WORD_OB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OBA_NODE),
     None,
     Some(&WORD_OBC_NODE),
@@ -89428,12 +89428,12 @@ static WORD_OB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OBY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBY_CHILDREN),
+static WORD_OBY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBY_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ekt"),
@@ -89442,12 +89442,12 @@ pub static WORD_OBY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=3,
 };
 
-static WORD_OBV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBV_CHILDREN),
+static WORD_OBV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBV_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ersation"),
         dictgen::InsensitiveStr::Ascii("ersations"),
@@ -89481,23 +89481,23 @@ pub static WORD_OBV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_OBU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBU_CHILDREN),
+static WORD_OBU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sing")],
     values: &[&["abusing"]],
     range: 4..=4,
 };
 
-static WORD_OBT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBT_CHILDREN),
+static WORD_OBT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aien"),
         dictgen::InsensitiveStr::Ascii("aiend"),
@@ -89541,12 +89541,12 @@ pub static WORD_OBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_OBS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBS_CHILDREN),
+static WORD_OBS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("colescence"),
         dictgen::InsensitiveStr::Ascii("cruity"),
@@ -89668,23 +89668,23 @@ pub static WORD_OBS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_OBN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBN_CHILDREN),
+static WORD_OBN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ject")],
     values: &[&["object"]],
     range: 4..=4,
 };
 
-static WORD_OBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBL_CHILDREN),
+static WORD_OBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eek"),
         dictgen::InsensitiveStr::Ascii("eekly"),
@@ -89724,12 +89724,12 @@ pub static WORD_OBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_OBJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBJ_CHILDREN),
+static WORD_OBJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ec"),
         dictgen::InsensitiveStr::Ascii("ecct"),
@@ -89807,12 +89807,12 @@ pub static WORD_OBJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_OBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBI_CHILDREN),
+static WORD_OBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("edence"),
@@ -89840,12 +89840,12 @@ pub static WORD_OBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_OBH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBH_CHILDREN),
+static WORD_OBH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ectification"),
@@ -89869,12 +89869,12 @@ pub static WORD_OBH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_OBG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBG_CHILDREN),
+static WORD_OBG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBG_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -89883,12 +89883,12 @@ pub static WORD_OBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_OBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBE_CHILDREN),
+static WORD_OBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("diance"),
@@ -89988,34 +89988,34 @@ pub static WORD_OBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_OBD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBD_CHILDREN),
+static WORD_OBD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBD_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("isian")],
     values: &[&["obsidian"]],
     range: 5..=5,
 };
 
-static WORD_OBC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBC_CHILDREN),
+static WORD_OBC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ject")],
     values: &[&["object"]],
     range: 4..=4,
 };
 
-static WORD_OBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBA_CHILDREN),
+static WORD_OBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mination"),
         dictgen::InsensitiveStr::Ascii("tinable"),
@@ -90039,12 +90039,12 @@ pub static WORD_OBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_OA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OA_CHILDREN),
+static WORD_OA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ker"),
         dictgen::InsensitiveStr::Ascii("kereous"),
@@ -90072,12 +90072,12 @@ pub static WORD_OA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_N_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_N_CHILDREN),
+static WORD_N_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_N_CHILDREN),
     value: None,
 };
 
-static WORD_N_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_N_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NA_NODE),
     None,
     Some(&WORD_NC_NODE),
@@ -90106,23 +90106,23 @@ static WORD_N_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NY_CHILDREN),
+static WORD_NY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NY_CHILDREN),
     value: None,
 };
 
-pub static WORD_NY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mber")],
     values: &[&["number"]],
     range: 4..=4,
 };
 
-static WORD_NW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NW_CHILDREN),
+static WORD_NW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -90131,12 +90131,12 @@ pub static WORD_NW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=1,
 };
 
-static WORD_NV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NV_CHILDREN),
+static WORD_NV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ironment"),
@@ -90145,12 +90145,12 @@ pub static WORD_NV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_NU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NU_CHILDREN),
+static WORD_NU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NU_CHILDREN),
     value: None,
 };
 
-static WORD_NU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NUA_NODE),
     Some(&WORD_NUB_NODE),
     Some(&WORD_NUC_NODE),
@@ -90179,12 +90179,12 @@ static WORD_NU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUT_CHILDREN),
+static WORD_NUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irent"),
         dictgen::InsensitiveStr::Ascii("irents"),
@@ -90240,12 +90240,12 @@ pub static WORD_NUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_NUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUS_CHILDREN),
+static WORD_NUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aince"),
         dictgen::InsensitiveStr::Ascii("ance"),
@@ -90255,12 +90255,12 @@ pub static WORD_NUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUR_CHILDREN),
+static WORD_NUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emburg"),
         dictgen::InsensitiveStr::Ascii("ish"),
@@ -90288,12 +90288,12 @@ pub static WORD_NUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_NUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUN_CHILDREN),
+static WORD_NUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("bers"),
@@ -90303,12 +90303,12 @@ pub static WORD_NUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_NUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUM_CHILDREN),
+static WORD_NUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bber"),
         dictgen::InsensitiveStr::Ascii("bbered"),
@@ -90412,12 +90412,12 @@ pub static WORD_NUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_NUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUL_CHILDREN),
+static WORD_NUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("cear"),
@@ -90445,12 +90445,12 @@ pub static WORD_NUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_NUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUI_CHILDREN),
+static WORD_NUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sans"),
         dictgen::InsensitiveStr::Ascii("sanse"),
@@ -90466,12 +90466,12 @@ pub static WORD_NUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_NUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUE_CHILDREN),
+static WORD_NUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rological"),
         dictgen::InsensitiveStr::Ascii("rons"),
@@ -90493,12 +90493,12 @@ pub static WORD_NUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_NUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUC_CHILDREN),
+static WORD_NUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elar"),
         dictgen::InsensitiveStr::Ascii("elus"),
@@ -90520,12 +90520,12 @@ pub static WORD_NUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUB_CHILDREN),
+static WORD_NUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ering"),
@@ -90536,12 +90536,12 @@ pub static WORD_NUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_NUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUA_CHILDREN),
+static WORD_NUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghty"),
         dictgen::InsensitiveStr::Ascii("tilus"),
@@ -90550,12 +90550,12 @@ pub static WORD_NUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NT_CHILDREN),
+static WORD_NT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ification"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -90564,12 +90564,12 @@ pub static WORD_NT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_NS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NS_CHILDREN),
+static WORD_NS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tall"),
         dictgen::InsensitiveStr::Ascii("tallation"),
@@ -90589,12 +90589,12 @@ pub static WORD_NS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_NR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NR_CHILDREN),
+static WORD_NR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eferenced"),
         dictgen::InsensitiveStr::Ascii("ivana"),
@@ -90605,12 +90605,12 @@ pub static WORD_NR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_NO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NO_CHILDREN),
+static WORD_NO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NO_CHILDREN),
     value: None,
 };
 
-static WORD_NO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_NOB_NODE),
     Some(&WORD_NOC_NODE),
@@ -90639,23 +90639,23 @@ static WORD_NO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOY_CHILDREN),
+static WORD_NOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOY_CHILDREN),
     value: Some(&["not"]),
 };
 
-pub static WORD_NOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_NOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOW_CHILDREN),
+static WORD_NOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adys"),
         dictgen::InsensitiveStr::Ascii("days"),
@@ -90673,12 +90673,12 @@ pub static WORD_NOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_NOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOV_CHILDREN),
+static WORD_NOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eau"),
         dictgen::InsensitiveStr::Ascii("embeard"),
@@ -90706,12 +90706,12 @@ pub static WORD_NOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_NOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NOT_CHILDREN),
+static WORD_NOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NOT_CHILDREN),
     value: None,
 };
 
-static WORD_NOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NOT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NOTA_NODE),
     Some(&WORD_NOTB_NODE),
     Some(&WORD_NOTC_NODE),
@@ -90740,23 +90740,23 @@ static WORD_NOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NOTW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTW_CHILDREN),
+static WORD_NOTW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hithstanding")],
     values: &[&["notwithstanding"]],
     range: 12..=12,
 };
 
-static WORD_NOTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTT_CHILDREN),
+static WORD_NOTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTT_CHILDREN),
     value: Some(&["not"]),
 };
 
-pub static WORD_NOTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aion"),
         dictgen::InsensitiveStr::Ascii("aions"),
@@ -90765,23 +90765,23 @@ pub static WORD_NOTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_NOTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTS_CHILDREN),
+static WORD_NOTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["notes", "note"]],
     range: 1..=1,
 };
 
-static WORD_NOTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTO_CHILDREN),
+static WORD_NOTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("focation"),
@@ -90815,23 +90815,23 @@ pub static WORD_NOTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_NOTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTN_CHILDREN),
+static WORD_NOTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["nothing"]],
     range: 3..=3,
 };
 
-static WORD_NOTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTM_CHILDREN),
+static WORD_NOTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alize"),
         dictgen::InsensitiveStr::Ascii("alized"),
@@ -90842,12 +90842,12 @@ pub static WORD_NOTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_NOTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NOTI_CHILDREN),
+static WORD_NOTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NOTI_CHILDREN),
     value: None,
 };
 
-static WORD_NOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NOTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_NOTIC_NODE),
@@ -90876,12 +90876,12 @@ static WORD_NOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NOTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIT_CHILDREN),
+static WORD_NOTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifers"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -90890,23 +90890,23 @@ pub static WORD_NOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_NOTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIR_CHILDREN),
+static WORD_NOTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ications")],
     values: &[&["notifications"]],
     range: 8..=8,
 };
 
-static WORD_NOTIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIG_CHILDREN),
+static WORD_NOTIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -90915,12 +90915,12 @@ pub static WORD_NOTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_NOTIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIF_CHILDREN),
+static WORD_NOTIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acation"),
         dictgen::InsensitiveStr::Ascii("acations"),
@@ -91014,23 +91014,23 @@ pub static WORD_NOTIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_NOTID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTID_CHILDREN),
+static WORD_NOTID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTID_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["notify"]],
     range: 1..=1,
 };
 
-static WORD_NOTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIC_CHILDREN),
+static WORD_NOTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("abely"),
@@ -91070,12 +91070,12 @@ pub static WORD_NOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_NOTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTH_CHILDREN),
+static WORD_NOTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTH_CHILDREN),
     value: Some(&["north"]),
 };
 
-pub static WORD_NOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ern"),
@@ -91103,12 +91103,12 @@ pub static WORD_NOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_NOTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTF_CHILDREN),
+static WORD_NOTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -91118,12 +91118,12 @@ pub static WORD_NOTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_NOTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTE_CHILDREN),
+static WORD_NOTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ably"),
@@ -91149,34 +91149,34 @@ pub static WORD_NOTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_NOTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTC_CHILDREN),
+static WORD_NOTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iable")],
     values: &[&["noticeable"]],
     range: 5..=5,
 };
 
-static WORD_NOTB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTB_CHILDREN),
+static WORD_NOTB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eooks")],
     values: &[&["notebooks"]],
     range: 5..=5,
 };
 
-static WORD_NOTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTA_CHILDREN),
+static WORD_NOTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bley"),
         dictgen::InsensitiveStr::Ascii("blly"),
@@ -91200,12 +91200,12 @@ pub static WORD_NOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_NOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOS_CHILDREN),
+static WORD_NOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("taglia"),
         dictgen::InsensitiveStr::Ascii("taglic"),
@@ -91249,12 +91249,12 @@ pub static WORD_NOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_NOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NOR_CHILDREN),
+static WORD_NOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NOR_CHILDREN),
     value: None,
 };
 
-static WORD_NOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NORA_NODE),
     None,
     None,
@@ -91283,12 +91283,12 @@ static WORD_NOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NORW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORW_CHILDREN),
+static WORD_NORW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egain"),
         dictgen::InsensitiveStr::Ascii("egin"),
@@ -91298,12 +91298,12 @@ pub static WORD_NORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_NORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORT_CHILDREN),
+static WORD_NORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heat"),
         dictgen::InsensitiveStr::Ascii("hen"),
@@ -91335,23 +91335,23 @@ pub static WORD_NORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_NORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORN_CHILDREN),
+static WORD_NORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["normal"]],
     range: 2..=2,
 };
 
-static WORD_NORM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORM_CHILDREN),
+static WORD_NORM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailzation"),
         dictgen::InsensitiveStr::Ascii("aized"),
@@ -91425,23 +91425,23 @@ pub static WORD_NORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_NORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORI_CHILDREN),
+static WORD_NORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fications")],
     values: &[&["notifications"]],
     range: 9..=9,
 };
 
-static WORD_NORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORH_CHILDREN),
+static WORD_NORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ern"),
         dictgen::InsensitiveStr::Ascii("teast"),
@@ -91459,23 +91459,23 @@ pub static WORD_NORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_NORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORE_CHILDREN),
+static WORD_NORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORE_CHILDREN),
     value: Some(&["nor", "more", "node", "note"]),
 };
 
-pub static WORD_NORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_NORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORA_CHILDREN),
+static WORD_NORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lize"),
@@ -91517,34 +91517,34 @@ pub static WORD_NORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_NOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOP_CHILDREN),
+static WORD_NOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tifying")],
     values: &[&["notifying"]],
     range: 7..=7,
 };
 
-static WORD_NOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOO_CHILDREN),
+static WORD_NOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOO_CHILDREN),
     value: Some(&["no"]),
 };
 
-pub static WORD_NOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_NON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NON_CHILDREN),
+static WORD_NON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NON_CHILDREN),
     value: None,
 };
 
-pub static WORD_NON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("combatents"),
         dictgen::InsensitiveStr::Ascii("deteministic"),
@@ -91596,12 +91596,12 @@ pub static WORD_NON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_NOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOM_CHILDREN),
+static WORD_NOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("bered"),
@@ -91643,12 +91643,12 @@ pub static WORD_NOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_NOJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOJ_CHILDREN),
+static WORD_NOJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ification"),
         dictgen::InsensitiveStr::Ascii("ifications"),
@@ -91657,12 +91657,12 @@ pub static WORD_NOJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=10,
 };
 
-static WORD_NOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOI_CHILDREN),
+static WORD_NOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ser"),
@@ -91672,34 +91672,34 @@ pub static WORD_NOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_NOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOH_CHILDREN),
+static WORD_NOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ypen")],
     values: &[&["nohyphen"]],
     range: 4..=4,
 };
 
-static WORD_NOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOG_CHILDREN),
+static WORD_NOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ht")],
     values: &[&["night"]],
     range: 2..=2,
 };
 
-static WORD_NOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOF_CHILDREN),
+static WORD_NOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -91715,23 +91715,23 @@ pub static WORD_NOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_NOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOE_CHILDREN),
+static WORD_NOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOE_CHILDREN),
     value: Some(&["not", "no", "node", "know", "now", "note"]),
 };
 
-pub static WORD_NOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("xistent")],
     values: &[&["nonexistent"]],
     range: 7..=7,
 };
 
-static WORD_NOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOD_CHILDREN),
+static WORD_NOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("els"),
@@ -91749,12 +91749,12 @@ pub static WORD_NOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_NOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOC_CHILDREN),
+static WORD_NOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ontinuable"),
         dictgen::InsensitiveStr::Ascii("trune"),
@@ -91772,12 +91772,12 @@ pub static WORD_NOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_NOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOB_CHILDREN),
+static WORD_NOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ady"),
         dictgen::InsensitiveStr::Ascii("oday"),
@@ -91786,12 +91786,12 @@ pub static WORD_NOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_NN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NN_CHILDREN),
+static WORD_NN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eeded"),
@@ -91813,12 +91813,12 @@ pub static WORD_NN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_NM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NM_CHILDREN),
+static WORD_NM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("emonic"),
@@ -91828,23 +91828,23 @@ pub static WORD_NM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_NL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NL_CHILDREN),
+static WORD_NL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["only"]],
     range: 1..=1,
 };
 
-static WORD_NK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NK_CHILDREN),
+static WORD_NK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NK_CHILDREN),
     value: None,
 };
 
-pub static WORD_NK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nown"),
         dictgen::InsensitiveStr::Ascii("ow"),
@@ -91854,12 +91854,12 @@ pub static WORD_NK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_NI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NI_CHILDREN),
+static WORD_NI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NI_CHILDREN),
     value: None,
 };
 
-static WORD_NI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NIA_NODE),
     Some(&WORD_NIB_NODE),
     Some(&WORD_NIC_NODE),
@@ -91888,12 +91888,12 @@ static WORD_NI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIV_CHILDREN),
+static WORD_NIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erse"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -91907,23 +91907,23 @@ pub static WORD_NIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_NIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIU_CHILDREN),
+static WORD_NIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sance")],
     values: &[&["nuisance"]],
     range: 5..=5,
 };
 
-static WORD_NIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIT_CHILDREN),
+static WORD_NIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -91949,12 +91949,12 @@ pub static WORD_NIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_NIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIR_CHILDREN),
+static WORD_NIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("togen"),
         dictgen::InsensitiveStr::Ascii("vanna"),
@@ -91963,34 +91963,34 @@ pub static WORD_NIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_NIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIP_CHILDREN),
+static WORD_NIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ticking")],
     values: &[&["nitpicking"]],
     range: 7..=7,
 };
 
-static WORD_NIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIO_CHILDREN),
+static WORD_NIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["not"]],
     range: 1..=1,
 };
 
-static WORD_NIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIN_CHILDREN),
+static WORD_NIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIN_CHILDREN),
     value: Some(&["inn", "min", "bin", "nine"]),
 };
 
-pub static WORD_NIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eth"),
         dictgen::InsensitiveStr::Ascii("ima"),
@@ -92018,12 +92018,12 @@ pub static WORD_NIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_NIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIM_CHILDREN),
+static WORD_NIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ations"),
         dictgen::InsensitiveStr::Ascii("ph"),
@@ -92059,23 +92059,23 @@ pub static WORD_NIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_NIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIL_CHILDREN),
+static WORD_NIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ihism")],
     values: &[&["nihilism"]],
     range: 5..=5,
 };
 
-static WORD_NIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIH_CHILDREN),
+static WORD_NIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilim"),
         dictgen::InsensitiveStr::Ascii("ilisim"),
@@ -92086,12 +92086,12 @@ pub static WORD_NIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_NIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIG_CHILDREN),
+static WORD_NIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hbor"),
         dictgen::InsensitiveStr::Ascii("hborhood"),
@@ -92143,12 +92143,12 @@ pub static WORD_NIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_NIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIF_CHILDREN),
+static WORD_NIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -92157,12 +92157,12 @@ pub static WORD_NIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_NIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIE_CHILDREN),
+static WORD_NIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("arest"),
@@ -92198,12 +92198,12 @@ pub static WORD_NIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_NIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIC_CHILDREN),
+static WORD_NIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kame"),
         dictgen::InsensitiveStr::Ascii("kanme"),
@@ -92213,45 +92213,45 @@ pub static WORD_NIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIB_CHILDREN),
+static WORD_NIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mle")],
     values: &[&["nimble"]],
     range: 3..=3,
 };
 
-static WORD_NIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIA_CHILDREN),
+static WORD_NIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ve")],
     values: &[&["naive"]],
     range: 2..=2,
 };
 
-static WORD_NF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NF_CHILDREN),
+static WORD_NF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ormation")],
     values: &[&["information"]],
     range: 8..=8,
 };
 
-static WORD_NE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NE_CHILDREN),
+static WORD_NE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NE_CHILDREN),
     value: None,
 };
 
-static WORD_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEA_NODE),
     None,
     Some(&WORD_NEC_NODE),
@@ -92280,12 +92280,12 @@ static WORD_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEX_CHILDREN),
+static WORD_NEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essary"),
         dictgen::InsensitiveStr::Ascii("ting"),
@@ -92295,12 +92295,12 @@ pub static WORD_NEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_NEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEW_CHILDREN),
+static WORD_NEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("anced"),
@@ -92372,12 +92372,12 @@ pub static WORD_NEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_NEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEV_CHILDREN),
+static WORD_NEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elop"),
         dictgen::InsensitiveStr::Ascii("elope"),
@@ -92411,12 +92411,12 @@ pub static WORD_NEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_NEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEU_CHILDREN),
+static WORD_NEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meric"),
         dictgen::InsensitiveStr::Ascii("monectomies"),
@@ -92478,12 +92478,12 @@ pub static WORD_NEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_NET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NET_CHILDREN),
+static WORD_NET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NET_CHILDREN),
     value: None,
 };
 
-pub static WORD_NET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acpe"),
         dictgen::InsensitiveStr::Ascii("boook"),
@@ -92535,12 +92535,12 @@ pub static WORD_NET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_NES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NES_CHILDREN),
+static WORD_NES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NES_CHILDREN),
     value: None,
 };
 
-pub static WORD_NES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cesaries"),
         dictgen::InsensitiveStr::Ascii("cesarily"),
@@ -92618,12 +92618,12 @@ pub static WORD_NES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_NER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NER_CHILDREN),
+static WORD_NER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NER_CHILDREN),
     value: None,
 };
 
-pub static WORD_NER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -92661,23 +92661,23 @@ pub static WORD_NER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_NEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEP_CHILDREN),
+static WORD_NEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tun")],
     values: &[&["neptune"]],
     range: 3..=3,
 };
 
-static WORD_NEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEO_CHILDREN),
+static WORD_NEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("litic"),
         dictgen::InsensitiveStr::Ascii("roscience"),
@@ -92686,34 +92686,34 @@ pub static WORD_NEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_NEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEN_CHILDREN),
+static WORD_NEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("viroment")],
     values: &[&["environment"]],
     range: 8..=8,
 };
 
-static WORD_NEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEL_CHILDREN),
+static WORD_NEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ink")],
     values: &[&["netlink"]],
     range: 3..=3,
 };
 
-static WORD_NEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEI_CHILDREN),
+static WORD_NEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEI_CHILDREN),
     value: None,
 };
 
-static WORD_NEI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_NEIB_NODE),
     Some(&WORD_NEIC_NODE),
@@ -92742,23 +92742,23 @@ static WORD_NEI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIT_CHILDREN),
+static WORD_NEIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["neither"]],
     range: 2..=2,
 };
 
-static WORD_NEIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEIG_CHILDREN),
+static WORD_NEIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEIG_CHILDREN),
     value: None,
 };
 
-static WORD_NEIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEIG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_NEIGB_NODE),
     None,
@@ -92787,23 +92787,23 @@ static WORD_NEIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGT_CHILDREN),
+static WORD_NEIGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("her")],
     values: &[&["neither"]],
     range: 3..=3,
 };
 
-static WORD_NEIGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEIGH_CHILDREN),
+static WORD_NEIGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEIGH_CHILDREN),
     value: None,
 };
 
-static WORD_NEIGH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEIGH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_NEIGHB_NODE),
     None,
@@ -92832,12 +92832,12 @@ static WORD_NEIGH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIGHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHT_CHILDREN),
+static WORD_NEIGHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHT_CHILDREN),
     value: Some(&["neither"]),
 };
 
-pub static WORD_NEIGHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bor"),
         dictgen::InsensitiveStr::Ascii("borhood"),
@@ -92877,12 +92877,12 @@ pub static WORD_NEIGHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_NEIGHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHR_CHILDREN),
+static WORD_NEIGHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orhood"),
@@ -92910,12 +92910,12 @@ pub static WORD_NEIGHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_NEIGHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHO_CHILDREN),
+static WORD_NEIGHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("br"),
         dictgen::InsensitiveStr::Ascii("brhood"),
@@ -92953,23 +92953,23 @@ pub static WORD_NEIGHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_NEIGHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHE_CHILDREN),
+static WORD_NEIGHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["neither"]],
     range: 1..=1,
 };
 
-static WORD_NEIGHB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEIGHB_CHILDREN),
+static WORD_NEIGHB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEIGHB_CHILDREN),
     value: None,
 };
 
-static WORD_NEIGHB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEIGHB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEIGHBA_NODE),
     Some(&WORD_NEIGHBB_NODE),
     None,
@@ -92998,12 +92998,12 @@ static WORD_NEIGHB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIGHBU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBU_CHILDREN),
+static WORD_NEIGHBU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rhood"),
@@ -93021,12 +93021,12 @@ pub static WORD_NEIGHBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_NEIGHBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBR_CHILDREN),
+static WORD_NEIGHBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBR_CHILDREN),
     value: Some(&["neighbor"]),
 };
 
-pub static WORD_NEIGHBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ohood"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -93035,12 +93035,12 @@ pub static WORD_NEIGHBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_NEIGHBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEIGHBO_CHILDREN),
+static WORD_NEIGHBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEIGHBO_CHILDREN),
     value: None,
 };
 
-static WORD_NEIGHBO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEIGHBO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEIGHBOA_NODE),
     None,
     None,
@@ -93069,12 +93069,12 @@ static WORD_NEIGHBO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIGHBOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOU_CHILDREN),
+static WORD_NEIGHBOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("rbood"),
@@ -93142,12 +93142,12 @@ pub static WORD_NEIGHBOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_NEIGHBOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOT_CHILDREN),
+static WORD_NEIGHBOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOT_CHILDREN),
     value: Some(&["neighbor"]),
 };
 
-pub static WORD_NEIGHBOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hood"),
         dictgen::InsensitiveStr::Ascii("hoods"),
@@ -93157,23 +93157,23 @@ pub static WORD_NEIGHBOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=5,
 };
 
-static WORD_NEIGHBOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOS_CHILDREN),
+static WORD_NEIGHBOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOS_CHILDREN),
     value: Some(&["neighbors"]),
 };
 
-pub static WORD_NEIGHBOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_NEIGHBOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOR_CHILDREN),
+static WORD_NEIGHBOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ds"),
         dictgen::InsensitiveStr::Ascii("ehood"),
@@ -93227,12 +93227,12 @@ pub static WORD_NEIGHBOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=7,
 };
 
-static WORD_NEIGHBOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOO_CHILDREN),
+static WORD_NEIGHBOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -93264,23 +93264,23 @@ pub static WORD_NEIGHBOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=7,
 };
 
-static WORD_NEIGHBOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOI_CHILDREN),
+static WORD_NEIGHBOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["neighboring"]],
     range: 2..=2,
 };
 
-static WORD_NEIGHBOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOH_CHILDREN),
+static WORD_NEIGHBOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ood"),
         dictgen::InsensitiveStr::Ascii("oods"),
@@ -93289,12 +93289,12 @@ pub static WORD_NEIGHBOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 3..=4,
 };
 
-static WORD_NEIGHBOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOA_CHILDREN),
+static WORD_NEIGHBOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rds"),
@@ -93303,12 +93303,12 @@ pub static WORD_NEIGHBOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=3,
 };
 
-static WORD_NEIGHBH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBH_CHILDREN),
+static WORD_NEIGHBH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orhood"),
@@ -93326,12 +93326,12 @@ pub static WORD_NEIGHBH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=7,
 };
 
-static WORD_NEIGHBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBE_CHILDREN),
+static WORD_NEIGHBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -93453,12 +93453,12 @@ pub static WORD_NEIGHBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_NEIGHBB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBB_CHILDREN),
+static WORD_NEIGHBB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orhood"),
@@ -93476,12 +93476,12 @@ pub static WORD_NEIGHBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=7,
 };
 
-static WORD_NEIGHBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBA_CHILDREN),
+static WORD_NEIGHBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rhood"),
@@ -93499,12 +93499,12 @@ pub static WORD_NEIGHBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_NEIGB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGB_CHILDREN),
+static WORD_NEIGB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hor"),
         dictgen::InsensitiveStr::Ascii("horhood"),
@@ -93542,23 +93542,23 @@ pub static WORD_NEIGB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_NEIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIC_CHILDREN),
+static WORD_NEIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["niece", "nice"]],
     range: 1..=1,
 };
 
-static WORD_NEIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIB_CHILDREN),
+static WORD_NEIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hbors"),
         dictgen::InsensitiveStr::Ascii("hbours"),
@@ -93578,12 +93578,12 @@ pub static WORD_NEIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_NEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEG_CHILDREN),
+static WORD_NEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEG_CHILDREN),
     value: None,
 };
 
-static WORD_NEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGA_NODE),
     None,
     None,
@@ -93612,23 +93612,23 @@ static WORD_NEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGT_CHILDREN),
+static WORD_NEGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ive")],
     values: &[&["negative"]],
     range: 3..=3,
 };
 
-static WORD_NEGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEGO_CHILDREN),
+static WORD_NEGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEGO_CHILDREN),
     value: None,
 };
 
-static WORD_NEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEGO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGOA_NODE),
     None,
     Some(&WORD_NEGOC_NODE),
@@ -93657,12 +93657,12 @@ static WORD_NEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGOZ_NODE),
 ];
 
-static WORD_NEGOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOZ_CHILDREN),
+static WORD_NEGOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -93688,12 +93688,12 @@ pub static WORD_NEGOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEGOT_CHILDREN),
+static WORD_NEGOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEGOT_CHILDREN),
     value: None,
 };
 
-static WORD_NEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEGOT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGOTA_NODE),
     None,
     None,
@@ -93722,12 +93722,12 @@ static WORD_NEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEGOTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEGOTI_CHILDREN),
+static WORD_NEGOTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEGOTI_CHILDREN),
     value: None,
 };
 
-static WORD_NEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEGOTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGOTIA_NODE),
     Some(&WORD_NEGOTIB_NODE),
     Some(&WORD_NEGOTIC_NODE),
@@ -93756,12 +93756,12 @@ static WORD_NEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEGOTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIT_CHILDREN),
+static WORD_NEGOTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -93819,12 +93819,12 @@ pub static WORD_NEGOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_NEGOTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIO_CHILDREN),
+static WORD_NEGOTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -93908,23 +93908,23 @@ pub static WORD_NEGOTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_NEGOTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIN_CHILDREN),
+static WORD_NEGOTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ate")],
     values: &[&["negotiate"]],
     range: 3..=3,
 };
 
-static WORD_NEGOTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIC_CHILDREN),
+static WORD_NEGOTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -93950,23 +93950,23 @@ pub static WORD_NEGOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=6,
 };
 
-static WORD_NEGOTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIB_CHILDREN),
+static WORD_NEGOTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["negotiable"]],
     range: 2..=2,
 };
 
-static WORD_NEGOTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIA_CHILDREN),
+static WORD_NEGOTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ning"),
@@ -93998,12 +93998,12 @@ pub static WORD_NEGOTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=5,
 };
 
-static WORD_NEGOTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTH_CHILDREN),
+static WORD_NEGOTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -94029,12 +94029,12 @@ pub static WORD_NEGOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_NEGOTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTA_CHILDREN),
+static WORD_NEGOTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -94126,12 +94126,12 @@ pub static WORD_NEGOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_NEGOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOS_CHILDREN),
+static WORD_NEGOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -94157,12 +94157,12 @@ pub static WORD_NEGOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOP_CHILDREN),
+static WORD_NEGOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tionsotiable"),
         dictgen::InsensitiveStr::Ascii("tionsotiate"),
@@ -94188,12 +94188,12 @@ pub static WORD_NEGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 11..=14,
 };
 
-static WORD_NEGOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOI_CHILDREN),
+static WORD_NEGOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tate"),
@@ -94219,12 +94219,12 @@ pub static WORD_NEGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOG_CHILDREN),
+static WORD_NEGOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iated"),
         dictgen::InsensitiveStr::Ascii("tiable"),
@@ -94252,12 +94252,12 @@ pub static WORD_NEGOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_NEGOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOC_CHILDREN),
+static WORD_NEGOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -94283,12 +94283,12 @@ pub static WORD_NEGOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOA_CHILDREN),
+static WORD_NEGOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("te"),
@@ -94332,12 +94332,12 @@ pub static WORD_NEGOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_NEGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGL_CHILDREN),
+static WORD_NEGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acting"),
         dictgen::InsensitiveStr::Ascii("agence"),
@@ -94383,12 +94383,12 @@ pub static WORD_NEGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGI_CHILDREN),
+static WORD_NEGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("lgence"),
@@ -94426,12 +94426,12 @@ pub static WORD_NEGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_NEGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGE_CHILDREN),
+static WORD_NEGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("lcting"),
@@ -94441,12 +94441,12 @@ pub static WORD_NEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_NEGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGA_CHILDREN),
+static WORD_NEGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ive"),
         dictgen::InsensitiveStr::Ascii("rive"),
@@ -94494,23 +94494,23 @@ pub static WORD_NEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_NEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEF_CHILDREN),
+static WORD_NEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arios")],
     values: &[&["nefarious"]],
     range: 5..=5,
 };
 
-static WORD_NEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEE_CHILDREN),
+static WORD_NEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("deed"),
@@ -94566,12 +94566,12 @@ pub static WORD_NEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_NED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NED_CHILDREN),
+static WORD_NED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NED_CHILDREN),
     value: Some(&["need", "end"]),
 };
 
-pub static WORD_NED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -94601,12 +94601,12 @@ pub static WORD_NED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_NEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEC_CHILDREN),
+static WORD_NEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEC_CHILDREN),
     value: None,
 };
 
-static WORD_NEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NECA_NODE),
     None,
     Some(&WORD_NECC_NODE),
@@ -94635,23 +94635,23 @@ static WORD_NEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECT_CHILDREN),
+static WORD_NECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECT_CHILDREN),
     value: Some(&["next"]),
 };
 
-pub static WORD_NECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ode")],
     values: &[&["netcode"]],
     range: 3..=3,
 };
 
-static WORD_NECS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECS_CHILDREN),
+static WORD_NECS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sarily"),
         dictgen::InsensitiveStr::Ascii("sary"),
@@ -94660,12 +94660,12 @@ pub static WORD_NECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_NECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECR_CHILDREN),
+static WORD_NECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omacer"),
         dictgen::InsensitiveStr::Ascii("omamcer"),
@@ -94683,12 +94683,12 @@ pub static WORD_NECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_NECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECO_CHILDREN),
+static WORD_NECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nstitutional"),
         dictgen::InsensitiveStr::Ascii("rmancer"),
@@ -94697,12 +94697,12 @@ pub static WORD_NECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=12,
 };
 
-static WORD_NECK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECK_CHILDREN),
+static WORD_NECK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECK_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bead"),
         dictgen::InsensitiveStr::Ascii("bearders"),
@@ -94738,23 +94738,23 @@ pub static WORD_NECK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_NECH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECH_CHILDREN),
+static WORD_NECH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("anism")],
     values: &[&["mechanism"]],
     range: 5..=5,
 };
 
-static WORD_NECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECE_CHILDREN),
+static WORD_NECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("assary"),
         dictgen::InsensitiveStr::Ascii("sarily"),
@@ -94832,12 +94832,12 @@ pub static WORD_NECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_NECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECC_CHILDREN),
+static WORD_NECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecarily"),
         dictgen::InsensitiveStr::Ascii("ecary"),
@@ -94869,12 +94869,12 @@ pub static WORD_NECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_NECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECA_CHILDREN),
+static WORD_NECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ssary"),
         dictgen::InsensitiveStr::Ascii("ssery"),
@@ -94885,12 +94885,12 @@ pub static WORD_NECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_NEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEA_CHILDREN),
+static WORD_NEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -94922,12 +94922,12 @@ pub static WORD_NEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ND_CHILDREN),
+static WORD_ND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ND_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efined"),
         dictgen::InsensitiveStr::Ascii("erline"),
@@ -94938,12 +94938,12 @@ pub static WORD_ND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_NC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NC_CHILDREN),
+static WORD_NC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("essarily"),
@@ -94963,12 +94963,12 @@ pub static WORD_NC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_NA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NA_CHILDREN),
+static WORD_NA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NA_CHILDREN),
     value: None,
 };
 
-static WORD_NA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NAA_NODE),
     None,
     Some(&WORD_NAC_NODE),
@@ -94997,12 +94997,12 @@ static WORD_NA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_NAZ_NODE),
 ];
 
-static WORD_NAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAZ_CHILDREN),
+static WORD_NAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ereth"),
         dictgen::InsensitiveStr::Ascii("ionalists"),
@@ -95011,12 +95011,12 @@ pub static WORD_NAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_NAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAY_CHILDREN),
+static WORD_NAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bhor"),
         dictgen::InsensitiveStr::Ascii("bhorhood"),
@@ -95056,12 +95056,12 @@ pub static WORD_NAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_NAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAX_CHILDREN),
+static WORD_NAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAX_CHILDREN),
     value: Some(&["max", "nad"]),
 };
 
-pub static WORD_NAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ima"),
         dictgen::InsensitiveStr::Ascii("imal"),
@@ -95071,12 +95071,12 @@ pub static WORD_NAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_NAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAW_CHILDREN),
+static WORD_NAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sea"),
         dictgen::InsensitiveStr::Ascii("seous"),
@@ -95100,12 +95100,12 @@ pub static WORD_NAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_NAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAV_CHILDREN),
+static WORD_NAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agate"),
         dictgen::InsensitiveStr::Ascii("agating"),
@@ -95153,12 +95153,12 @@ pub static WORD_NAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_NAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAU_CHILDREN),
+static WORD_NAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esous"),
         dictgen::InsensitiveStr::Ascii("ghtly"),
@@ -95190,12 +95190,12 @@ pub static WORD_NAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NAT_CHILDREN),
+static WORD_NAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NAT_CHILDREN),
     value: None,
 };
 
-static WORD_NAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_NATC_NODE),
@@ -95224,23 +95224,23 @@ static WORD_NAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NATV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATV_CHILDREN),
+static WORD_NATV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("igation")],
     values: &[&["navigation"]],
     range: 7..=7,
 };
 
-static WORD_NATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATU_CHILDREN),
+static WORD_NATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arally"),
         dictgen::InsensitiveStr::Ascii("ilus"),
@@ -95264,12 +95264,12 @@ pub static WORD_NATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_NATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATR_CHILDREN),
+static WORD_NATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ual"),
         dictgen::InsensitiveStr::Ascii("ually"),
@@ -95278,12 +95278,12 @@ pub static WORD_NATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_NATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATI_CHILDREN),
+static WORD_NATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("evly"),
         dictgen::InsensitiveStr::Ascii("nal"),
@@ -95415,12 +95415,12 @@ pub static WORD_NATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_NATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATC_CHILDREN),
+static WORD_NATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hed"),
         dictgen::InsensitiveStr::Ascii("hes"),
@@ -95429,12 +95429,12 @@ pub static WORD_NATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_NAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAS_CHILDREN),
+static WORD_NAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euous"),
         dictgen::InsensitiveStr::Ascii("hvile"),
@@ -95498,12 +95498,12 @@ pub static WORD_NAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_NAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAR_CHILDREN),
+static WORD_NAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("cassism"),
@@ -95619,12 +95619,12 @@ pub static WORD_NAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_NAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAP_CHILDREN),
+static WORD_NAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cakes"),
         dictgen::InsensitiveStr::Ascii("loeon"),
@@ -95664,23 +95664,23 @@ pub static WORD_NAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_NAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAO_CHILDREN),
+static WORD_NAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pleon")],
     values: &[&["napoleon"]],
     range: 5..=5,
 };
 
-static WORD_NAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAN_CHILDREN),
+static WORD_NAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("osecod"),
@@ -95704,12 +95704,12 @@ pub static WORD_NAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_NAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAM_CHILDREN),
+static WORD_NAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAM_CHILDREN),
     value: Some(&["name"]),
 };
 
-pub static WORD_NAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aed"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -95773,12 +95773,12 @@ pub static WORD_NAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_NAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAI_CHILDREN),
+static WORD_NAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bhor"),
         dictgen::InsensitiveStr::Ascii("bhorhood"),
@@ -95810,23 +95810,23 @@ pub static WORD_NAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_NAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAH_CHILDREN),
+static WORD_NAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sville")],
     values: &[&["nashville"]],
     range: 6..=6,
 };
 
-static WORD_NAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAG_CHILDREN),
+static WORD_NAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("atively"),
@@ -95846,23 +95846,23 @@ pub static WORD_NAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_NAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAF_CHILDREN),
+static WORD_NAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erious")],
     values: &[&["nefarious"]],
     range: 6..=6,
 };
 
-static WORD_NAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAE_CHILDREN),
+static WORD_NAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("rly"),
@@ -95871,23 +95871,23 @@ pub static WORD_NAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_NAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAD_CHILDREN),
+static WORD_NAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["badly"]],
     range: 2..=2,
 };
 
-static WORD_NAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAC_CHILDREN),
+static WORD_NAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ionalistic"),
         dictgen::InsensitiveStr::Ascii("ionalists"),
@@ -95897,23 +95897,23 @@ pub static WORD_NAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=10,
 };
 
-static WORD_NAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAA_CHILDREN),
+static WORD_NAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("me")],
     values: &[&["name"]],
     range: 2..=2,
 };
 
-static WORD_M_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_M_CHILDREN),
+static WORD_M_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_M_CHILDREN),
     value: None,
 };
 
-static WORD_M_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_M_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MA_NODE),
     None,
     Some(&WORD_MC_NODE),
@@ -95942,12 +95942,12 @@ static WORD_M_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MY_CHILDREN),
+static WORD_MY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -96029,34 +96029,34 @@ pub static WORD_MY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_MW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MW_CHILDREN),
+static WORD_MW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MW_CHILDREN),
     value: None,
 };
 
-pub static WORD_MW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cos")],
     values: &[&["macos"]],
     range: 3..=3,
 };
 
-static WORD_MV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MV_CHILDREN),
+static WORD_MV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oes")],
     values: &[&["moves"]],
     range: 3..=3,
 };
 
-static WORD_MU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MU_CHILDREN),
+static WORD_MU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MU_CHILDREN),
     value: None,
 };
 
-static WORD_MU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_MUC_NODE),
@@ -96085,23 +96085,23 @@ static WORD_MU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MUY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUY_CHILDREN),
+static WORD_MUY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("st")],
     values: &[&["must"]],
     range: 2..=2,
 };
 
-static WORD_MUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUT_CHILDREN),
+static WORD_MUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ablility"),
         dictgen::InsensitiveStr::Ascii("ablity"),
@@ -96235,12 +96235,12 @@ pub static WORD_MUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_MUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUS_CHILDREN),
+static WORD_MUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cel"),
         dictgen::InsensitiveStr::Ascii("cels"),
@@ -96314,12 +96314,12 @@ pub static WORD_MUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_MUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUR_CHILDREN),
+static WORD_MUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("derd"),
         dictgen::InsensitiveStr::Ascii("dererd"),
@@ -96343,12 +96343,12 @@ pub static WORD_MUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUN_CHILDREN),
+static WORD_MUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bers"),
         dictgen::InsensitiveStr::Ascii("chis"),
@@ -96378,12 +96378,12 @@ pub static WORD_MUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_MUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUM_CHILDREN),
+static WORD_MUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("bers"),
@@ -96392,12 +96392,12 @@ pub static WORD_MUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_MUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MUL_CHILDREN),
+static WORD_MUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MUL_CHILDREN),
     value: None,
 };
 
-static WORD_MUL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MUL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -96426,12 +96426,12 @@ static WORD_MUL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MULT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MULT_CHILDREN),
+static WORD_MULT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MULT_CHILDREN),
     value: None,
 };
 
-static WORD_MULT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MULT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -96460,12 +96460,12 @@ static WORD_MULT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MULTY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTY_CHILDREN),
+static WORD_MULTY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTY_CHILDREN),
     value: Some(&["multi"]),
 };
 
-pub static WORD_MULTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("player"),
         dictgen::InsensitiveStr::Ascii("plying"),
@@ -96474,12 +96474,12 @@ pub static WORD_MULTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_MULTP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTP_CHILDREN),
+static WORD_MULTP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("art"),
         dictgen::InsensitiveStr::Ascii("ile"),
@@ -96507,12 +96507,12 @@ pub static WORD_MULTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MULTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTL_CHILDREN),
+static WORD_MULTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("iple"),
@@ -96538,12 +96538,12 @@ pub static WORD_MULTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MULTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MULTI_CHILDREN),
+static WORD_MULTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MULTI_CHILDREN),
     value: None,
 };
 
-static WORD_MULTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MULTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_MULTIB_NODE),
     Some(&WORD_MULTIC_NODE),
@@ -96572,23 +96572,23 @@ static WORD_MULTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MULTIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIX_CHILDREN),
+static WORD_MULTIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("site")],
     values: &[&["multisite"]],
     range: 4..=4,
 };
 
-static WORD_MULTIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIV_CHILDREN),
+static WORD_MULTIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erese"),
         dictgen::InsensitiveStr::Ascii("riate"),
@@ -96597,12 +96597,12 @@ pub static WORD_MULTIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=5,
 };
 
-static WORD_MULTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIT_CHILDREN),
+static WORD_MULTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aking"),
         dictgen::InsensitiveStr::Ascii("aksing"),
@@ -96622,23 +96622,23 @@ pub static WORD_MULTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_MULTIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIS_CHILDREN),
+static WORD_MULTIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mapling")],
     values: &[&["multisampling"]],
     range: 7..=7,
 };
 
-static WORD_MULTIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIP_CHILDREN),
+static WORD_MULTIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alyer"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -96730,12 +96730,12 @@ pub static WORD_MULTIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_MULTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIN_CHILDREN),
+static WORD_MULTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atinal"),
         dictgen::InsensitiveStr::Ascii("ationella"),
@@ -96745,23 +96745,23 @@ pub static WORD_MULTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_MULTIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIM_CHILDREN),
+static WORD_MULTIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ational")],
     values: &[&["multinational"]],
     range: 7..=7,
 };
 
-static WORD_MULTIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIL_CHILDREN),
+static WORD_MULTIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angual"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -96777,34 +96777,34 @@ pub static WORD_MULTIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_MULTIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIF_CHILDREN),
+static WORD_MULTIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uction")],
     values: &[&["multifunction"]],
     range: 6..=6,
 };
 
-static WORD_MULTIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIE_CHILDREN),
+static WORD_MULTIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cast")],
     values: &[&["multicast"]],
     range: 4..=4,
 };
 
-static WORD_MULTID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTID_CHILDREN),
+static WORD_MULTID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTID_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imensinal"),
         dictgen::InsensitiveStr::Ascii("imension"),
@@ -96820,12 +96820,12 @@ pub static WORD_MULTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 8..=11,
 };
 
-static WORD_MULTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIC_CHILDREN),
+static WORD_MULTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ultralism"),
@@ -96834,12 +96834,12 @@ pub static WORD_MULTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_MULTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIB_CHILDREN),
+static WORD_MULTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("ye"),
@@ -96848,34 +96848,34 @@ pub static WORD_MULTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=2,
 };
 
-static WORD_MULS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULS_CHILDREN),
+static WORD_MULS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ims")],
     values: &[&["muslims"]],
     range: 3..=3,
 };
 
-static WORD_MULL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULL_CHILDREN),
+static WORD_MULL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tiple")],
     values: &[&["multiple"]],
     range: 5..=5,
 };
 
-static WORD_MULI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULI_CHILDREN),
+static WORD_MULI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("part"),
         dictgen::InsensitiveStr::Ascii("ple"),
@@ -96937,23 +96937,23 @@ pub static WORD_MULI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_MUK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUK_CHILDREN),
+static WORD_MUK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("titasking")],
     values: &[&["multitasking"]],
     range: 9..=9,
 };
 
-static WORD_MUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUI_CHILDREN),
+static WORD_MUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ltiple"),
         dictgen::InsensitiveStr::Ascii("ltiples"),
@@ -96962,23 +96962,23 @@ pub static WORD_MUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_MUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUH_CHILDREN),
+static WORD_MUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUH_CHILDREN),
     value: Some(&["much"]),
 };
 
-pub static WORD_MUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("c")],
     values: &[&["much"]],
     range: 1..=1,
 };
 
-static WORD_MUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUF_CHILDREN),
+static WORD_MUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fings"),
         dictgen::InsensitiveStr::Ascii("finus"),
@@ -96987,12 +96987,12 @@ pub static WORD_MUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_MUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUE_CHILDREN),
+static WORD_MUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sums"),
         dictgen::InsensitiveStr::Ascii("xt"),
@@ -97001,12 +97001,12 @@ pub static WORD_MUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_MUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUD_CHILDREN),
+static WORD_MUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ering"),
@@ -97017,12 +97017,12 @@ pub static WORD_MUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUC_CHILDREN),
+static WORD_MUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUC_CHILDREN),
     value: Some(&["much"]),
 };
 
-pub static WORD_MUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isians"),
         dictgen::InsensitiveStr::Ascii("nhies"),
@@ -97032,12 +97032,12 @@ pub static WORD_MUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_MT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MT_CHILDREN),
+static WORD_MT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hod"),
         dictgen::InsensitiveStr::Ascii("hods"),
@@ -97047,12 +97047,12 @@ pub static WORD_MT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_MS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MS_CHILDREN),
+static WORD_MS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ot"),
         dictgen::InsensitiveStr::Ascii("sing"),
@@ -97063,12 +97063,12 @@ pub static WORD_MS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_MR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MR_CHILDREN),
+static WORD_MR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oe"),
         dictgen::InsensitiveStr::Ascii("oning"),
@@ -97077,12 +97077,12 @@ pub static WORD_MR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MP_CHILDREN),
+static WORD_MP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ortant"),
@@ -97091,12 +97091,12 @@ pub static WORD_MP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_MO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MO_CHILDREN),
+static WORD_MO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MO_CHILDREN),
     value: None,
 };
 
-static WORD_MO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MOA_NODE),
     Some(&WORD_MOB_NODE),
     Some(&WORD_MOC_NODE),
@@ -97125,12 +97125,12 @@ static WORD_MO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MOZ_NODE),
 ];
 
-static WORD_MOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOZ_CHILDREN),
+static WORD_MOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iila"),
         dictgen::InsensitiveStr::Ascii("ila"),
@@ -97156,12 +97156,12 @@ pub static WORD_MOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_MOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOV_CHILDREN),
+static WORD_MOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebackwrd"),
         dictgen::InsensitiveStr::Ascii("eble"),
@@ -97221,12 +97221,12 @@ pub static WORD_MOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_MOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOU_CHILDREN),
+static WORD_MOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dle"),
         dictgen::InsensitiveStr::Ascii("dles"),
@@ -97294,12 +97294,12 @@ pub static WORD_MOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOT_CHILDREN),
+static WORD_MOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("eef"),
@@ -97407,12 +97407,12 @@ pub static WORD_MOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_MOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOS_CHILDREN),
+static WORD_MOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("iturizer"),
@@ -97454,12 +97454,12 @@ pub static WORD_MOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_MOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOR_CHILDREN),
+static WORD_MOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOR_CHILDREN),
     value: Some(&["more"]),
 };
 
-pub static WORD_MOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atlity"),
         dictgen::InsensitiveStr::Ascii("bidley"),
@@ -97577,12 +97577,12 @@ pub static WORD_MOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_MOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOP_CHILDREN),
+static WORD_MOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dule"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -97592,12 +97592,12 @@ pub static WORD_MOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOO_CHILDREN),
+static WORD_MOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dify"),
         dictgen::InsensitiveStr::Ascii("nligt"),
@@ -97607,12 +97607,12 @@ pub static WORD_MOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_MON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MON_CHILDREN),
+static WORD_MON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MON_CHILDREN),
     value: None,
 };
 
-static WORD_MON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MONA_NODE),
     None,
     Some(&WORD_MONC_NODE),
@@ -97641,23 +97641,23 @@ static WORD_MON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MONY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONY_CHILDREN),
+static WORD_MONY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONY_CHILDREN),
     value: Some(&["money"]),
 };
 
-pub static WORD_MONY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_MONU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONU_CHILDREN),
+static WORD_MONU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mentaal"),
         dictgen::InsensitiveStr::Ascii("mentais"),
@@ -97685,12 +97685,12 @@ pub static WORD_MONU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONT_CHILDREN),
+static WORD_MONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aban"),
         dictgen::InsensitiveStr::Ascii("aeg"),
@@ -97748,12 +97748,12 @@ pub static WORD_MONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_MONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONS_CHILDREN),
+static WORD_MONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("day"),
         dictgen::InsensitiveStr::Ascii("errat"),
@@ -97789,12 +97789,12 @@ pub static WORD_MONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MONR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONR_CHILDREN),
+static WORD_MONR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achy"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -97803,12 +97803,12 @@ pub static WORD_MONR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MONO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONO_CHILDREN),
+static WORD_MONO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chome"),
         dictgen::InsensitiveStr::Ascii("chorome"),
@@ -97906,12 +97906,12 @@ pub static WORD_MONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_MONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONN_CHILDREN),
+static WORD_MONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("th"),
         dictgen::InsensitiveStr::Ascii("ths"),
@@ -97920,23 +97920,23 @@ pub static WORD_MONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MONK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONK_CHILDREN),
+static WORD_MONK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["monkeys"]],
     range: 3..=3,
 };
 
-static WORD_MONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONI_CHILDREN),
+static WORD_MONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("tary"),
@@ -97966,12 +97966,12 @@ pub static WORD_MONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONG_CHILDREN),
+static WORD_MONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("los"),
         dictgen::InsensitiveStr::Ascii("oles"),
@@ -97981,12 +97981,12 @@ pub static WORD_MONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONE_CHILDREN),
+static WORD_MONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONE_CHILDREN),
     value: Some(&["mono", "money", "none"]),
 };
 
-pub static WORD_MONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("staries"),
         dictgen::InsensitiveStr::Ascii("stary"),
@@ -98002,34 +98002,34 @@ pub static WORD_MONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_MOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOND_CHILDREN),
+static WORD_MOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ey")],
     values: &[&["monday", "money", "monkey"]],
     range: 2..=2,
 };
 
-static WORD_MONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONC_CHILDREN),
+static WORD_MONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hrome")],
     values: &[&["monochrome"]],
     range: 5..=5,
 };
 
-static WORD_MONA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONA_CHILDREN),
+static WORD_MONA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gomous"),
         dictgen::InsensitiveStr::Ascii("gomy"),
@@ -98051,12 +98051,12 @@ pub static WORD_MONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_MOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOM_CHILDREN),
+static WORD_MOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ementarily"),
@@ -98118,12 +98118,12 @@ pub static WORD_MOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_MOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOL_CHILDREN),
+static WORD_MOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eclues"),
         dictgen::InsensitiveStr::Ascii("eculair"),
@@ -98161,12 +98161,12 @@ pub static WORD_MOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_MOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOI_CHILDREN),
+static WORD_MOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bles"),
@@ -98208,12 +98208,12 @@ pub static WORD_MOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOH_CHILDREN),
+static WORD_MOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ammedan"),
         dictgen::InsensitiveStr::Ascii("ammedans"),
@@ -98222,12 +98222,12 @@ pub static WORD_MOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_MOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOF_CHILDREN),
+static WORD_MOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dified"),
         dictgen::InsensitiveStr::Ascii("ification"),
@@ -98247,12 +98247,12 @@ pub static WORD_MOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_MOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOE_CHILDREN),
+static WORD_MOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lcules"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -98270,12 +98270,12 @@ pub static WORD_MOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_MOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MOD_CHILDREN),
+static WORD_MOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MOD_CHILDREN),
     value: None,
 };
 
-static WORD_MOD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MOD_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -98304,12 +98304,12 @@ static WORD_MOD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MODY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODY_CHILDREN),
+static WORD_MODY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fing"),
         dictgen::InsensitiveStr::Ascii("fy"),
@@ -98319,12 +98319,12 @@ pub static WORD_MODY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MODU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODU_CHILDREN),
+static WORD_MODU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alr"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -98356,23 +98356,23 @@ pub static WORD_MODU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_MODT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODT_CHILDREN),
+static WORD_MODT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ified")],
     values: &[&["modified"]],
     range: 5..=5,
 };
 
-static WORD_MODP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODP_CHILDREN),
+static WORD_MODP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("robbing"),
         dictgen::InsensitiveStr::Ascii("robeing"),
@@ -98381,12 +98381,12 @@ pub static WORD_MODP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_MODL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODL_CHILDREN),
+static WORD_MODL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -98402,12 +98402,12 @@ pub static WORD_MODL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_MODI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MODI_CHILDREN),
+static WORD_MODI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MODI_CHILDREN),
     value: None,
 };
 
-static WORD_MODI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MODI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_MODIC_NODE),
@@ -98436,56 +98436,56 @@ static WORD_MODI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MODIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIY_CHILDREN),
+static WORD_MODIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["modifying"]],
     range: 3..=3,
 };
 
-static WORD_MODIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIV_CHILDREN),
+static WORD_MODIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ational")],
     values: &[&["motivational"]],
     range: 7..=7,
 };
 
-static WORD_MODIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIR_CHILDREN),
+static WORD_MODIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["moderation"]],
     range: 5..=5,
 };
 
-static WORD_MODIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIO_CHILDREN),
+static WORD_MODIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fication")],
     values: &[&["modification"]],
     range: 8..=8,
 };
 
-static WORD_MODIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIL_CHILDREN),
+static WORD_MODIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -98494,12 +98494,12 @@ pub static WORD_MODIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_MODII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODII_CHILDREN),
+static WORD_MODII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODII_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("fier"),
@@ -98509,12 +98509,12 @@ pub static WORD_MODII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MODIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIF_CHILDREN),
+static WORD_MODIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("action"),
@@ -98632,12 +98632,12 @@ pub static WORD_MODIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_MODID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODID_CHILDREN),
+static WORD_MODID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODID_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fication"),
         dictgen::InsensitiveStr::Ascii("fications"),
@@ -98661,12 +98661,12 @@ pub static WORD_MODID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MODIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIC_CHILDREN),
+static WORD_MODIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -98675,12 +98675,12 @@ pub static WORD_MODIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_MODF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODF_CHILDREN),
+static WORD_MODF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -98766,12 +98766,12 @@ pub static WORD_MODF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_MODE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODE_CHILDREN),
+static WORD_MODE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -98829,12 +98829,12 @@ pub static WORD_MODE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_MODD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODD_CHILDREN),
+static WORD_MODD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("eled"),
@@ -98852,12 +98852,12 @@ pub static WORD_MODD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_MOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOC_CHILDREN),
+static WORD_MOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rochip"),
         dictgen::InsensitiveStr::Ascii("rochips"),
@@ -98897,12 +98897,12 @@ pub static WORD_MOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=14,
 };
 
-static WORD_MOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOB_CHILDREN),
+static WORD_MOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ify"),
         dictgen::InsensitiveStr::Ascii("ilitiy"),
@@ -98913,23 +98913,23 @@ pub static WORD_MOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_MOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOA_CHILDREN),
+static WORD_MOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("st")],
     values: &[&["most", "moat"]],
     range: 2..=2,
 };
 
-static WORD_MN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MN_CHILDREN),
+static WORD_MN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("emnonic"),
@@ -98947,12 +98947,12 @@ pub static WORD_MN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_MM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MM_CHILDREN),
+static WORD_MM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anifest"),
         dictgen::InsensitiveStr::Ascii("aped"),
@@ -98972,12 +98972,12 @@ pub static WORD_MM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_MK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MK_CHILDREN),
+static WORD_MK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -98989,23 +98989,23 @@ pub static WORD_MK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_MJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MJ_CHILDREN),
+static WORD_MJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("or")],
     values: &[&["major"]],
     range: 2..=2,
 };
 
-static WORD_MI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MI_CHILDREN),
+static WORD_MI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MI_CHILDREN),
     value: None,
 };
 
-static WORD_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MIA_NODE),
     None,
     Some(&WORD_MIC_NODE),
@@ -99034,12 +99034,12 @@ static WORD_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIX_CHILDREN),
+static WORD_MIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imum"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -99057,12 +99057,12 @@ pub static WORD_MIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_MIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIT_CHILDREN),
+static WORD_MIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gate"),
         dictgen::InsensitiveStr::Ascii("icate"),
@@ -99088,12 +99088,12 @@ pub static WORD_MIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_MIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MIS_CHILDREN),
+static WORD_MIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MIS_CHILDREN),
     value: Some(&["miss", "mist"]),
 };
 
-static WORD_MIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MIS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MISA_NODE),
     Some(&WORD_MISB_NODE),
     Some(&WORD_MISC_NODE),
@@ -99122,12 +99122,12 @@ static WORD_MIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MISY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISY_CHILDREN),
+static WORD_MISY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gonist"),
         dictgen::InsensitiveStr::Ascii("gonistic"),
@@ -99136,12 +99136,12 @@ pub static WORD_MISY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_MISU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISU_CHILDREN),
+static WORD_MISU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bderstanding"),
         dictgen::InsensitiveStr::Ascii("dnerstanding"),
@@ -99223,12 +99223,12 @@ pub static WORD_MISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=14,
 };
 
-static WORD_MIST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIST_CHILDREN),
+static WORD_MIST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIST_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("akedly"),
         dictgen::InsensitiveStr::Ascii("akengly"),
@@ -99298,12 +99298,12 @@ pub static WORD_MIST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_MISS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MISS_CHILDREN),
+static WORD_MISS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MISS_CHILDREN),
     value: None,
 };
 
-static WORD_MISS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MISS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MISSA_NODE),
     None,
     Some(&WORD_MISSC_NODE),
@@ -99332,12 +99332,12 @@ static WORD_MISS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MISSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSU_CHILDREN),
+static WORD_MISSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nderstanding"),
         dictgen::InsensitiveStr::Ascii("nderstood"),
@@ -99355,12 +99355,12 @@ pub static WORD_MISSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_MISST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISST_CHILDREN),
+static WORD_MISST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISST_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ake"),
         dictgen::InsensitiveStr::Ascii("aken"),
@@ -99378,23 +99378,23 @@ pub static WORD_MISST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MISSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSS_CHILDREN),
+static WORD_MISSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["missing"]],
     range: 3..=3,
 };
 
-static WORD_MISSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSP_CHILDREN),
+static WORD_MISSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eeling"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -99420,12 +99420,12 @@ pub static WORD_MISSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MISSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSO_CHILDREN),
+static WORD_MISSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nary"),
         dictgen::InsensitiveStr::Ascii("rui"),
@@ -99435,23 +99435,23 @@ pub static WORD_MISSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MISSN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSN_CHILDREN),
+static WORD_MISSN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["missing"]],
     range: 1..=1,
 };
 
-static WORD_MISSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSM_CHILDREN),
+static WORD_MISSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anaged"),
         dictgen::InsensitiveStr::Ascii("atch"),
@@ -99471,12 +99471,12 @@ pub static WORD_MISSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_MISSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSL_CHILDREN),
+static WORD_MISSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eading"),
@@ -99487,12 +99487,12 @@ pub static WORD_MISSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_MISSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSI_CHILDREN),
+static WORD_MISSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("gno"),
@@ -99544,12 +99544,12 @@ pub static WORD_MISSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_MISSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSE_CHILDREN),
+static WORD_MISSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nce"),
@@ -99558,12 +99558,12 @@ pub static WORD_MISSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_MISSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSC_CHILDREN),
+static WORD_MISSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lassified"),
         dictgen::InsensitiveStr::Ascii("lassifies"),
@@ -99589,12 +99589,12 @@ pub static WORD_MISSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=12,
 };
 
-static WORD_MISSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSA_CHILDREN),
+static WORD_MISSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("lignment"),
@@ -99603,12 +99603,12 @@ pub static WORD_MISSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_MISR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISR_CHILDREN),
+static WORD_MISR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eable"),
         dictgen::InsensitiveStr::Ascii("eably"),
@@ -99640,12 +99640,12 @@ pub static WORD_MISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=13,
 };
 
-static WORD_MISQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISQ_CHILDREN),
+static WORD_MISQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uito"),
         dictgen::InsensitiveStr::Ascii("uitos"),
@@ -99654,12 +99654,12 @@ pub static WORD_MISQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_MISP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISP_CHILDREN),
+static WORD_MISP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ell"),
         dictgen::InsensitiveStr::Ascii("elled"),
@@ -99681,12 +99681,12 @@ pub static WORD_MISP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=13,
 };
 
-static WORD_MISO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISO_CHILDREN),
+static WORD_MISO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ganist"),
         dictgen::InsensitiveStr::Ascii("ganistic"),
@@ -99748,23 +99748,23 @@ pub static WORD_MISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_MISN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISN_CHILDREN),
+static WORD_MISN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("adry")],
     values: &[&["misandry"]],
     range: 4..=4,
 };
 
-static WORD_MISM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISM_CHILDREN),
+static WORD_MISM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -99786,12 +99786,12 @@ pub static WORD_MISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_MISL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISL_CHILDREN),
+static WORD_MISL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abaled"),
         dictgen::InsensitiveStr::Ascii("abled"),
@@ -99805,12 +99805,12 @@ pub static WORD_MISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_MISI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISI_CHILDREN),
+static WORD_MISI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("mformed"),
@@ -99896,12 +99896,12 @@ pub static WORD_MISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_MISG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISG_CHILDREN),
+static WORD_MISG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oynist"),
         dictgen::InsensitiveStr::Ascii("oynistic"),
@@ -99910,12 +99910,12 @@ pub static WORD_MISG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_MISF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISF_CHILDREN),
+static WORD_MISF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ormed"),
         dictgen::InsensitiveStr::Ascii("ortunte"),
@@ -99931,12 +99931,12 @@ pub static WORD_MISF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_MISE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISE_CHILDREN),
+static WORD_MISE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laneous"),
         dictgen::InsensitiveStr::Ascii("laneously"),
@@ -99960,12 +99960,12 @@ pub static WORD_MISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_MISD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISD_CHILDREN),
+static WORD_MISD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ameanor"),
         dictgen::InsensitiveStr::Ascii("ameanors"),
@@ -99993,12 +99993,12 @@ pub static WORD_MISD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_MISC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISC_CHILDREN),
+static WORD_MISC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("airrage"),
         dictgen::InsensitiveStr::Ascii("allenaous"),
@@ -100076,23 +100076,23 @@ pub static WORD_MISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=12,
 };
 
-static WORD_MISB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISB_CHILDREN),
+static WORD_MISB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ehaive")],
     values: &[&["misbehave"]],
     range: 6..=6,
 };
 
-static WORD_MISA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISA_CHILDREN),
+static WORD_MISA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ke"),
         dictgen::InsensitiveStr::Ascii("ken"),
@@ -100120,12 +100120,12 @@ pub static WORD_MISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIR_CHILDREN),
+static WORD_MIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acalous"),
         dictgen::InsensitiveStr::Ascii("acilously"),
@@ -100233,23 +100233,23 @@ pub static WORD_MIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=14,
 };
 
-static WORD_MIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIP_CHILDREN),
+static WORD_MIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lementation")],
     values: &[&["implementation"]],
     range: 11..=11,
 };
 
-static WORD_MIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MIN_CHILDREN),
+static WORD_MIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MIN_CHILDREN),
     value: None,
 };
 
-static WORD_MIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MINA_NODE),
     None,
     None,
@@ -100278,12 +100278,12 @@ static WORD_MIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MINU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINU_CHILDREN),
+static WORD_MINU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -100311,12 +100311,12 @@ pub static WORD_MINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_MINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINT_CHILDREN),
+static WORD_MINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("ored"),
@@ -100336,12 +100336,12 @@ pub static WORD_MINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINS_CHILDREN),
+static WORD_MINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icule"),
         dictgen::InsensitiveStr::Ascii("iter"),
@@ -100361,12 +100361,12 @@ pub static WORD_MINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MINO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINO_CHILDREN),
+static WORD_MINO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ins"),
         dictgen::InsensitiveStr::Ascii("osha"),
@@ -100382,12 +100382,12 @@ pub static WORD_MINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_MINN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINN_CHILDREN),
+static WORD_MINN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eaoplis"),
         dictgen::InsensitiveStr::Ascii("eaplis"),
@@ -100417,12 +100417,12 @@ pub static WORD_MINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_MINM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINM_CHILDREN),
+static WORD_MINM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ize"),
@@ -100432,12 +100432,12 @@ pub static WORD_MINM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MINI_CHILDREN),
+static WORD_MINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MINI_CHILDREN),
     value: None,
 };
 
-static WORD_MINI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MINI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MINIA_NODE),
     None,
     None,
@@ -100466,12 +100466,12 @@ static WORD_MINI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MINIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIU_CHILDREN),
+static WORD_MINIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("ms"),
@@ -100481,12 +100481,12 @@ pub static WORD_MINIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_MINIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIT_CHILDREN),
+static WORD_MINIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ature"),
         dictgen::InsensitiveStr::Ascii("aure"),
@@ -100502,12 +100502,12 @@ pub static WORD_MINIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MINIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIS_CHILDREN),
+static WORD_MINIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clue"),
         dictgen::InsensitiveStr::Ascii("cue"),
@@ -100539,12 +100539,12 @@ pub static WORD_MINIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_MINIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIP_CHILDREN),
+static WORD_MINIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ulating"),
         dictgen::InsensitiveStr::Ascii("ulation"),
@@ -100554,12 +100554,12 @@ pub static WORD_MINIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_MININ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MININ_CHILDREN),
+static WORD_MININ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MININ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MININ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MININ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alist"),
@@ -100595,12 +100595,12 @@ pub static WORD_MININ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_MINIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIM_CHILDREN),
+static WORD_MINIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("alisitc"),
@@ -100664,34 +100664,34 @@ pub static WORD_MINIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MINIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIF_CHILDREN),
+static WORD_MINIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ys")],
     values: &[&["minifies"]],
     range: 2..=2,
 };
 
-static WORD_MINIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIA_CHILDREN),
+static WORD_MINIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["minimal"]],
     range: 1..=1,
 };
 
-static WORD_MING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MING_CHILDREN),
+static WORD_MING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MING_CHILDREN),
     value: None,
 };
 
-pub static WORD_MING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gw"),
         dictgen::InsensitiveStr::Ascii("iame"),
@@ -100700,12 +100700,12 @@ pub static WORD_MING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_MINE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINE_CHILDREN),
+static WORD_MINE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rales"),
         dictgen::InsensitiveStr::Ascii("ras"),
@@ -100715,12 +100715,12 @@ pub static WORD_MINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MIND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIND_CHILDREN),
+static WORD_MIND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIND_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("carck"),
         dictgen::InsensitiveStr::Ascii("crak"),
@@ -100740,12 +100740,12 @@ pub static WORD_MIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_MINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINA_CHILDREN),
+static WORD_MINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("milist"),
         dictgen::InsensitiveStr::Ascii("ture"),
@@ -100754,12 +100754,12 @@ pub static WORD_MINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_MIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIM_CHILDREN),
+static WORD_MIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("achd"),
@@ -100841,12 +100841,12 @@ pub static WORD_MIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_MIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MIL_CHILDREN),
+static WORD_MIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MIL_CHILDREN),
     value: None,
 };
 
-static WORD_MIL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MIL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MILA_NODE),
     None,
     None,
@@ -100875,23 +100875,23 @@ static WORD_MIL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MILY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILY_CHILDREN),
+static WORD_MILY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ew")],
     values: &[&["milieu"]],
     range: 2..=2,
 };
 
-static WORD_MILW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILW_CHILDREN),
+static WORD_MILW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILW_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("akuee"),
         dictgen::InsensitiveStr::Ascii("uakee"),
@@ -100900,23 +100900,23 @@ pub static WORD_MILW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_MILU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILU_CHILDREN),
+static WORD_MILU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("wakee")],
     values: &[&["milwaukee"]],
     range: 5..=5,
 };
 
-static WORD_MILT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILT_CHILDREN),
+static WORD_MILT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ary"),
         dictgen::InsensitiveStr::Ascii("iant"),
@@ -100936,12 +100936,12 @@ pub static WORD_MILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_MILL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILL_CHILDREN),
+static WORD_MILL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eneum"),
         dictgen::InsensitiveStr::Ascii("enia"),
@@ -101027,12 +101027,12 @@ pub static WORD_MILL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MILK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILK_CHILDREN),
+static WORD_MILK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("toast"),
         dictgen::InsensitiveStr::Ascii("toasts"),
@@ -101041,12 +101041,12 @@ pub static WORD_MILK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_MILI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILI_CHILDREN),
+static WORD_MILI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ary"),
         dictgen::InsensitiveStr::Ascii("cious"),
@@ -101106,12 +101106,12 @@ pub static WORD_MILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MILE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILE_CHILDREN),
+static WORD_MILE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("au"),
         dictgen::InsensitiveStr::Ascii("nnia"),
@@ -101135,12 +101135,12 @@ pub static WORD_MILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_MILA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILA_CHILDREN),
+static WORD_MILA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("ges"),
@@ -101150,12 +101150,12 @@ pub static WORD_MILA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIK_CHILDREN),
+static WORD_MIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rosecond"),
         dictgen::InsensitiveStr::Ascii("roseconds"),
@@ -101164,12 +101164,12 @@ pub static WORD_MIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=9,
 };
 
-static WORD_MII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MII_CHILDREN),
+static WORD_MII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MII_CHILDREN),
     value: None,
 };
 
-pub static WORD_MII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nimisation"),
         dictgen::InsensitiveStr::Ascii("nimise"),
@@ -101199,23 +101199,23 @@ pub static WORD_MII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=10,
 };
 
-static WORD_MIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIH_CHILDREN),
+static WORD_MIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["might"]],
     range: 1..=1,
 };
 
-static WORD_MIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIG_CHILDREN),
+static WORD_MIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -101253,12 +101253,12 @@ pub static WORD_MIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MID_CHILDREN),
+static WORD_MID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MID_CHILDREN),
     value: None,
 };
 
-pub static WORD_MID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("del"),
         dictgen::InsensitiveStr::Ascii("delware"),
@@ -101330,12 +101330,12 @@ pub static WORD_MID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MIC_CHILDREN),
+static WORD_MIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MIC_CHILDREN),
     value: None,
 };
 
-static WORD_MIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MIC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -101364,12 +101364,12 @@ static WORD_MIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MICR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MICR_CHILDREN),
+static WORD_MICR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MICR_CHILDREN),
     value: None,
 };
 
-static WORD_MICR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MICR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_MICRC_NODE),
@@ -101398,12 +101398,12 @@ static WORD_MICR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MICRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICRS_CHILDREN),
+static WORD_MICRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ft"),
         dictgen::InsensitiveStr::Ascii("oft"),
@@ -101412,12 +101412,12 @@ pub static WORD_MICRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MICRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICRP_CHILDREN),
+static WORD_MICRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hone"),
         dictgen::InsensitiveStr::Ascii("ohone"),
@@ -101426,12 +101426,12 @@ pub static WORD_MICRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_MICRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICRO_CHILDREN),
+static WORD_MICRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cender"),
         dictgen::InsensitiveStr::Ascii("centre"),
@@ -101557,12 +101557,12 @@ pub static WORD_MICRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=13,
 };
 
-static WORD_MICRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICRC_CHILDREN),
+static WORD_MICRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ontroller"),
         dictgen::InsensitiveStr::Ascii("ontrollers"),
@@ -101571,12 +101571,12 @@ pub static WORD_MICRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=10,
 };
 
-static WORD_MICO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICO_CHILDREN),
+static WORD_MICO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rcenter"),
         dictgen::InsensitiveStr::Ascii("rcode"),
@@ -101612,12 +101612,12 @@ pub static WORD_MICO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=13,
 };
 
-static WORD_MICH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICH_CHILDREN),
+static WORD_MICH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agan"),
         dictgen::InsensitiveStr::Ascii("elline"),
@@ -101635,23 +101635,23 @@ pub static WORD_MICH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_MICE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICE_CHILDREN),
+static WORD_MICE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["mice"]],
     range: 1..=1,
 };
 
-static WORD_MIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIA_CHILDREN),
+static WORD_MIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gic"),
         dictgen::InsensitiveStr::Ascii("gical"),
@@ -101661,23 +101661,23 @@ pub static WORD_MIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_MH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MH_CHILDREN),
+static WORD_MH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ytical")],
     values: &[&["mythical"]],
     range: 6..=6,
 };
 
-static WORD_ME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ME_CHILDREN),
+static WORD_ME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ME_CHILDREN),
     value: None,
 };
 
-static WORD_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MEA_NODE),
     Some(&WORD_MEB_NODE),
     Some(&WORD_MEC_NODE),
@@ -101706,12 +101706,12 @@ static WORD_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MEZ_NODE),
 ];
 
-static WORD_MEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEZ_CHILDREN),
+static WORD_MEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("morise"),
         dictgen::InsensitiveStr::Ascii("morised"),
@@ -101739,23 +101739,23 @@ pub static WORD_MEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=8,
 };
 
-static WORD_MEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEY_CHILDREN),
+static WORD_MEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEY_CHILDREN),
     value: Some(&["may"]),
 };
 
-pub static WORD_MEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("be")],
     values: &[&["maybe"]],
     range: 2..=2,
 };
 
-static WORD_MEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEX_CHILDREN),
+static WORD_MEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cian"),
         dictgen::InsensitiveStr::Ascii("cians"),
@@ -101779,12 +101779,12 @@ pub static WORD_MEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_MET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MET_CHILDREN),
+static WORD_MET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MET_CHILDREN),
     value: None,
 };
 
-static WORD_MET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MET_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_META_NODE),
     None,
     None,
@@ -101813,23 +101813,23 @@ static WORD_MET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_METT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METT_CHILDREN),
+static WORD_METT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METT_CHILDREN),
     value: None,
 };
 
-pub static WORD_METT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["meeting"]],
     range: 3..=3,
 };
 
-static WORD_METR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METR_CHILDREN),
+static WORD_METR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METR_CHILDREN),
     value: None,
 };
 
-pub static WORD_METR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apolis"),
         dictgen::InsensitiveStr::Ascii("i"),
@@ -101897,12 +101897,12 @@ pub static WORD_METR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_METO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METO_CHILDREN),
+static WORD_METO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METO_CHILDREN),
     value: None,
 };
 
-pub static WORD_METO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dologies"),
@@ -101926,23 +101926,23 @@ pub static WORD_METO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_METL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METL_CHILDREN),
+static WORD_METL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METL_CHILDREN),
     value: None,
 };
 
-pub static WORD_METL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("down")],
     values: &[&["meltdown"]],
     range: 4..=4,
 };
 
-static WORD_METI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METI_CHILDREN),
+static WORD_METI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METI_CHILDREN),
     value: None,
 };
 
-pub static WORD_METI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cs"),
         dictgen::InsensitiveStr::Ascii("for"),
@@ -101968,12 +101968,12 @@ pub static WORD_METI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_METH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METH_CHILDREN),
+static WORD_METH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METH_CHILDREN),
     value: None,
 };
 
-pub static WORD_METH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amatician"),
         dictgen::InsensitiveStr::Ascii("aphor"),
@@ -102049,12 +102049,12 @@ pub static WORD_METH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_METE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METE_CHILDREN),
+static WORD_METE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METE_CHILDREN),
     value: None,
 };
 
-pub static WORD_METE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("data"),
         dictgen::InsensitiveStr::Ascii("phorical"),
@@ -102080,23 +102080,23 @@ pub static WORD_METE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_METD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METD_CHILDREN),
+static WORD_METD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METD_CHILDREN),
     value: None,
 };
 
-pub static WORD_METD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ata")],
     values: &[&["metadata"]],
     range: 3..=3,
 };
 
-static WORD_META_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_META_CHILDREN),
+static WORD_META_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_META_CHILDREN),
     value: None,
 };
 
-pub static WORD_META_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_META_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("balism"),
         dictgen::InsensitiveStr::Ascii("bilism"),
@@ -102212,12 +102212,12 @@ pub static WORD_META_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_MES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MES_CHILDREN),
+static WORD_MES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MES_CHILDREN),
     value: None,
 };
 
-pub static WORD_MES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -102339,12 +102339,12 @@ pub static WORD_MES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_MER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MER_CHILDREN),
+static WORD_MER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MER_CHILDREN),
     value: None,
 };
 
-pub static WORD_MER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aj"),
         dictgen::InsensitiveStr::Ascii("ajes"),
@@ -102448,12 +102448,12 @@ pub static WORD_MER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_MEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEO_CHILDREN),
+static WORD_MEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ldic"),
         dictgen::InsensitiveStr::Ascii("ldies"),
@@ -102463,12 +102463,12 @@ pub static WORD_MEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEN_CHILDREN),
+static WORD_MEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("aingful"),
@@ -102566,12 +102566,12 @@ pub static WORD_MEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEM_CHILDREN),
+static WORD_MEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bershup"),
         dictgen::InsensitiveStr::Ascii("bersip"),
@@ -102691,12 +102691,12 @@ pub static WORD_MEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_MEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEL_CHILDREN),
+static WORD_MEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancoly"),
         dictgen::InsensitiveStr::Ascii("anotin"),
@@ -102752,23 +102752,23 @@ pub static WORD_MEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_MEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEK_CHILDREN),
+static WORD_MEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEK_CHILDREN),
     value: Some(&["me"]),
 };
 
-pub static WORD_MEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_MEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEI_CHILDREN),
+static WORD_MEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("da"),
         dictgen::InsensitiveStr::Ascii("dcare"),
@@ -102786,12 +102786,12 @@ pub static WORD_MEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEH_CHILDREN),
+static WORD_MEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("canic"),
         dictgen::InsensitiveStr::Ascii("canical"),
@@ -102823,12 +102823,12 @@ pub static WORD_MEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEG_CHILDREN),
+static WORD_MEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anism"),
         dictgen::InsensitiveStr::Ascii("athred"),
@@ -102839,12 +102839,12 @@ pub static WORD_MEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_MEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEE_CHILDREN),
+static WORD_MEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ans"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -102884,12 +102884,12 @@ pub static WORD_MEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MED_CHILDREN),
+static WORD_MED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MED_CHILDREN),
     value: None,
 };
 
-static WORD_MED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MED_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MEDA_NODE),
     None,
     None,
@@ -102918,12 +102918,12 @@ static WORD_MED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MEDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDO_CHILDREN),
+static WORD_MEDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icre"),
         dictgen::InsensitiveStr::Ascii("w"),
@@ -102933,12 +102933,12 @@ pub static WORD_MEDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_MEDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDI_CHILDREN),
+static WORD_MEDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("action"),
         dictgen::InsensitiveStr::Ascii("avel"),
@@ -103054,12 +103054,12 @@ pub static WORD_MEDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_MEDH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDH_CHILDREN),
+static WORD_MEDH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("od"),
         dictgen::InsensitiveStr::Ascii("ods"),
@@ -103068,12 +103068,12 @@ pub static WORD_MEDH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MEDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDE_CHILDREN),
+static WORD_MEDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ival"),
         dictgen::InsensitiveStr::Ascii("terranean"),
@@ -103083,12 +103083,12 @@ pub static WORD_MEDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_MEDD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDD_CHILDREN),
+static WORD_MEDD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("os"),
@@ -103097,12 +103097,12 @@ pub static WORD_MEDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_MEDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDA_CHILDREN),
+static WORD_MEDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDA_CHILDREN),
     value: Some(&["medal", "media", "meta"]),
 };
 
-pub static WORD_MEDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cine"),
         dictgen::InsensitiveStr::Ascii("i"),
@@ -103113,12 +103113,12 @@ pub static WORD_MEDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_MEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEC_CHILDREN),
+static WORD_MEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahinsm"),
         dictgen::InsensitiveStr::Ascii("ahinsms"),
@@ -103228,12 +103228,12 @@ pub static WORD_MEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_MEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEB_CHILDREN),
+static WORD_MEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -103255,12 +103255,12 @@ pub static WORD_MEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MEA_CHILDREN),
+static WORD_MEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MEA_CHILDREN),
     value: None,
 };
 
-static WORD_MEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MEA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MEAA_NODE),
     None,
     Some(&WORD_MEAC_NODE),
@@ -103289,12 +103289,12 @@ static WORD_MEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MEAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAU_CHILDREN),
+static WORD_MEAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("re"),
         dictgen::InsensitiveStr::Ascii("red"),
@@ -103322,12 +103322,12 @@ pub static WORD_MEAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MEAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAT_CHILDREN),
+static WORD_MEAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adata"),
         dictgen::InsensitiveStr::Ascii("ballers"),
@@ -103347,12 +103347,12 @@ pub static WORD_MEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MEAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAS_CHILDREN),
+static WORD_MEAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("surable"),
         dictgen::InsensitiveStr::Ascii("surably"),
@@ -103408,23 +103408,23 @@ pub static WORD_MEAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MEAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAR_CHILDREN),
+static WORD_MEAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAR_CHILDREN),
     value: Some(&["wear", "mere", "mare"]),
 };
 
-pub static WORD_MEAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["merely", "nearly"]],
     range: 2..=2,
 };
 
-static WORD_MEAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAN_CHILDREN),
+static WORD_MEAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -103466,23 +103466,23 @@ pub static WORD_MEAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MEAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAL_CHILDREN),
+static WORD_MEAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("flur")],
     values: &[&["millefleur"]],
     range: 4..=4,
 };
 
-static WORD_MEAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAI_CHILDREN),
+static WORD_MEAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -103491,12 +103491,12 @@ pub static WORD_MEAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_MEAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAG_CHILDREN),
+static WORD_MEAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thread"),
         dictgen::InsensitiveStr::Ascii("tron"),
@@ -103505,23 +103505,23 @@ pub static WORD_MEAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_MEAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAD_CHILDREN),
+static WORD_MEAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["meaning"]],
     range: 3..=3,
 };
 
-static WORD_MEAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAC_CHILDREN),
+static WORD_MEAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hanism"),
         dictgen::InsensitiveStr::Ascii("hanisms"),
@@ -103541,12 +103541,12 @@ pub static WORD_MEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_MEAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAA_CHILDREN),
+static WORD_MEAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sure"),
         dictgen::InsensitiveStr::Ascii("sured"),
@@ -103556,12 +103556,12 @@ pub static WORD_MEAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_MD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MD_CHILDREN),
+static WORD_MD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ification"),
         dictgen::InsensitiveStr::Ascii("ifications"),
@@ -103605,12 +103605,12 @@ pub static WORD_MD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_MC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MC_CHILDREN),
+static WORD_MC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alren"),
         dictgen::InsensitiveStr::Ascii("carhty"),
@@ -103660,12 +103660,12 @@ pub static WORD_MC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_MA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MA_CHILDREN),
+static WORD_MA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MA_CHILDREN),
     value: None,
 };
 
-static WORD_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MAA_NODE),
     Some(&WORD_MAB_NODE),
     Some(&WORD_MAC_NODE),
@@ -103694,23 +103694,23 @@ static WORD_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MAZ_NODE),
 ];
 
-static WORD_MAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAZ_CHILDREN),
+static WORD_MAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("illa")],
     values: &[&["mozilla"]],
     range: 4..=4,
 };
 
-static WORD_MAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAY_CHILDREN),
+static WORD_MAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alsia"),
         dictgen::InsensitiveStr::Ascii("alsian"),
@@ -103756,12 +103756,12 @@ pub static WORD_MAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAX_CHILDREN),
+static WORD_MAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imazing"),
         dictgen::InsensitiveStr::Ascii("imice"),
@@ -103809,34 +103809,34 @@ pub static WORD_MAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_MAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAW_CHILDREN),
+static WORD_MAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("soleum")],
     values: &[&["mausoleum"]],
     range: 6..=6,
 };
 
-static WORD_MAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAV_CHILDREN),
+static WORD_MAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rick")],
     values: &[&["maverick"]],
     range: 4..=4,
 };
 
-static WORD_MAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAU_CHILDREN),
+static WORD_MAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arder"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -103852,12 +103852,12 @@ pub static WORD_MAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAT_CHILDREN),
+static WORD_MAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAT_CHILDREN),
     value: None,
 };
 
-static WORD_MAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MATA_NODE),
     None,
     Some(&WORD_MATC_NODE),
@@ -103886,23 +103886,23 @@ static WORD_MAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MATZ_NODE),
 ];
 
-static WORD_MATZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATZ_CHILDREN),
+static WORD_MATZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ch")],
     values: &[&["match"]],
     range: 2..=2,
 };
 
-static WORD_MATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATT_CHILDREN),
+static WORD_MATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ern"),
         dictgen::InsensitiveStr::Ascii("erns"),
@@ -103918,23 +103918,23 @@ pub static WORD_MATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATS_CHILDREN),
+static WORD_MATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["master"]],
     range: 2..=2,
 };
 
-static WORD_MATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATR_CHILDREN),
+static WORD_MATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eial"),
         dictgen::InsensitiveStr::Ascii("eials"),
@@ -103962,12 +103962,12 @@ pub static WORD_MATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATI_CHILDREN),
+static WORD_MATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eral"),
         dictgen::InsensitiveStr::Ascii("eralism"),
@@ -103987,12 +103987,12 @@ pub static WORD_MATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_MATH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATH_CHILDREN),
+static WORD_MATH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amatical"),
         dictgen::InsensitiveStr::Ascii("amatician"),
@@ -104112,12 +104112,12 @@ pub static WORD_MATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_MATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATE_CHILDREN),
+static WORD_MATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("ials"),
@@ -104175,12 +104175,12 @@ pub static WORD_MATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_MATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATC_CHILDREN),
+static WORD_MATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATC_CHILDREN),
     value: Some(&["match"]),
 };
 
-pub static WORD_MATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bh"),
         dictgen::InsensitiveStr::Ascii("hamking"),
@@ -104210,12 +104210,12 @@ pub static WORD_MATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_MATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATA_CHILDREN),
+static WORD_MATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATA_CHILDREN),
     value: Some(&["meta", "mater"]),
 };
 
-pub static WORD_MATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ching"),
         dictgen::InsensitiveStr::Ascii("data"),
@@ -104239,12 +104239,12 @@ pub static WORD_MATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_MAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAS_CHILDREN),
+static WORD_MAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAS_CHILDREN),
     value: None,
 };
 
-static WORD_MAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MASA_NODE),
     None,
     Some(&WORD_MASC_NODE),
@@ -104273,23 +104273,23 @@ static WORD_MAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MASU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASU_CHILDREN),
+static WORD_MASU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("clinity")],
     values: &[&["masculinity"]],
     range: 7..=7,
 };
 
-static WORD_MAST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAST_CHILDREN),
+static WORD_MAST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAST_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eer"),
         dictgen::InsensitiveStr::Ascii("eires"),
@@ -104393,12 +104393,12 @@ pub static WORD_MAST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_MASS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASS_CHILDREN),
+static WORD_MASS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("acer"),
@@ -104458,23 +104458,23 @@ pub static WORD_MASS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_MASR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASR_CHILDREN),
+static WORD_MASR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hmallow")],
     values: &[&["marshmallow"]],
     range: 7..=7,
 };
 
-static WORD_MASQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASQ_CHILDREN),
+static WORD_MASQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uarade"),
         dictgen::InsensitiveStr::Ascii("urade"),
@@ -104483,12 +104483,12 @@ pub static WORD_MASQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_MASO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASO_CHILDREN),
+static WORD_MASO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ginistic"),
         dictgen::InsensitiveStr::Ascii("gynistic"),
@@ -104498,12 +104498,12 @@ pub static WORD_MASO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_MASK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASK_CHILDREN),
+static WORD_MASK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erading"),
         dictgen::InsensitiveStr::Ascii("eraid"),
@@ -104512,12 +104512,12 @@ pub static WORD_MASK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_MASI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASI_CHILDREN),
+static WORD_MASI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("cer"),
@@ -104527,12 +104527,12 @@ pub static WORD_MASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_MASH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASH_CHILDREN),
+static WORD_MASH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("etty"),
@@ -104550,12 +104550,12 @@ pub static WORD_MASH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_MASC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASC_CHILDREN),
+static WORD_MASC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arra"),
         dictgen::InsensitiveStr::Ascii("ulanity"),
@@ -104571,12 +104571,12 @@ pub static WORD_MASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_MASA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASA_CHILDREN),
+static WORD_MASA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cra"),
         dictgen::InsensitiveStr::Ascii("kist"),
@@ -104585,12 +104585,12 @@ pub static WORD_MASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAR_CHILDREN),
+static WORD_MAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAR_CHILDREN),
     value: None,
 };
 
-static WORD_MAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MARA_NODE),
     Some(&WORD_MARB_NODE),
     Some(&WORD_MARC_NODE),
@@ -104619,23 +104619,23 @@ static WORD_MAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MARZ_NODE),
 ];
 
-static WORD_MARZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARZ_CHILDREN),
+static WORD_MARZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARZ_CHILDREN),
     value: Some(&["march", "mars"]),
 };
 
-pub static WORD_MARZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_MARX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARX_CHILDREN),
+static WORD_MARX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isim"),
         dictgen::InsensitiveStr::Ascii("isit"),
@@ -104645,34 +104645,34 @@ pub static WORD_MARX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_MARV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARV_CHILDREN),
+static WORD_MARV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("elos")],
     values: &[&["marvelous"]],
     range: 4..=4,
 };
 
-static WORD_MARU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARU_CHILDREN),
+static WORD_MARU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ader")],
     values: &[&["marauder"]],
     range: 4..=4,
 };
 
-static WORD_MART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MART_CHILDREN),
+static WORD_MART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MART_CHILDREN),
     value: None,
 };
 
-pub static WORD_MART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ail"),
         dictgen::InsensitiveStr::Ascii("ain"),
@@ -104682,12 +104682,12 @@ pub static WORD_MART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARS_CHILDREN),
+static WORD_MARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hamllow"),
         dictgen::InsensitiveStr::Ascii("hamllows"),
@@ -104717,12 +104717,12 @@ pub static WORD_MARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_MARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARR_CHILDREN),
+static WORD_MARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("aige"),
@@ -104740,12 +104740,12 @@ pub static WORD_MARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARN_CHILDREN),
+static WORD_MARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iers"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -104754,23 +104754,23 @@ pub static WORD_MARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARM_CHILDREN),
+static WORD_MARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("elade")],
     values: &[&["marmalade"]],
     range: 5..=5,
 };
 
-static WORD_MARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARL_CHILDREN),
+static WORD_MARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bes"),
         dictgen::InsensitiveStr::Ascii("iyn"),
@@ -104779,12 +104779,12 @@ pub static WORD_MARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_MARK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARK_CHILDREN),
+static WORD_MARK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aup"),
         dictgen::InsensitiveStr::Ascii("ede"),
@@ -104820,12 +104820,12 @@ pub static WORD_MARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MARJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARJ_CHILDREN),
+static WORD_MARJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iuana"),
         dictgen::InsensitiveStr::Ascii("ority"),
@@ -104834,12 +104834,12 @@ pub static WORD_MARJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_MARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARI_CHILDREN),
+static WORD_MARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abd"),
         dictgen::InsensitiveStr::Ascii("age"),
@@ -104883,12 +104883,12 @@ pub static WORD_MARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MARH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARH_CHILDREN),
+static WORD_MARH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sal"),
         dictgen::InsensitiveStr::Ascii("smallow"),
@@ -104898,12 +104898,12 @@ pub static WORD_MARH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_MARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARG_CHILDREN),
+static WORD_MARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anilize"),
         dictgen::InsensitiveStr::Ascii("anilized"),
@@ -104949,12 +104949,12 @@ pub static WORD_MARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_MARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARE_CHILDREN),
+static WORD_MARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kting"),
         dictgen::InsensitiveStr::Ascii("vlous"),
@@ -104963,23 +104963,23 @@ pub static WORD_MARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_MARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARD_CHILDREN),
+static WORD_MARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("own")],
     values: &[&["markdown"]],
     range: 3..=3,
 };
 
-static WORD_MARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARC_CHILDREN),
+static WORD_MARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hmallows"),
         dictgen::InsensitiveStr::Ascii("ros"),
@@ -104988,12 +104988,12 @@ pub static WORD_MARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_MARB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARB_CHILDREN),
+static WORD_MARB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("els"),
         dictgen::InsensitiveStr::Ascii("leds"),
@@ -105002,12 +105002,12 @@ pub static WORD_MARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARA_CHILDREN),
+static WORD_MARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("coni"),
         dictgen::InsensitiveStr::Ascii("deur"),
@@ -105027,12 +105027,12 @@ pub static WORD_MARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_MAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAP_CHILDREN),
+static WORD_MAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -105062,12 +105062,12 @@ pub static WORD_MAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_MAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAN_CHILDREN),
+static WORD_MAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAN_CHILDREN),
     value: None,
 };
 
-static WORD_MAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MANA_NODE),
     None,
     None,
@@ -105096,12 +105096,12 @@ static WORD_MAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MANY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANY_CHILDREN),
+static WORD_MANY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -105111,12 +105111,12 @@ pub static WORD_MANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_MANU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MANU_CHILDREN),
+static WORD_MANU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MANU_CHILDREN),
     value: None,
 };
 
-static WORD_MANU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MANU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MANUA_NODE),
     None,
     None,
@@ -105145,23 +105145,23 @@ static WORD_MANU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MANUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUV_CHILDREN),
+static WORD_MANUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["maneuver"]],
     range: 2..=2,
 };
 
-static WORD_MANUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUP_CHILDREN),
+static WORD_MANUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilated"),
         dictgen::InsensitiveStr::Ascii("ilating"),
@@ -105189,12 +105189,12 @@ pub static WORD_MANUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_MANUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUL_CHILDREN),
+static WORD_MANUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -105212,12 +105212,12 @@ pub static WORD_MANUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_MANUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUF_CHILDREN),
+static WORD_MANUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("actered"),
@@ -105329,12 +105329,12 @@ pub static WORD_MANUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_MANUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUE_CHILDREN),
+static WORD_MANUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ll"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -105352,12 +105352,12 @@ pub static WORD_MANUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_MANUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUA_CHILDREN),
+static WORD_MANUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("les"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -105368,12 +105368,12 @@ pub static WORD_MANUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MANT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANT_CHILDREN),
+static WORD_MANT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainable"),
@@ -105403,12 +105403,12 @@ pub static WORD_MANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANS_CHILDREN),
+static WORD_MANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alughter"),
         dictgen::InsensitiveStr::Ascii("laugher"),
@@ -105426,12 +105426,12 @@ pub static WORD_MANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_MANO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANO_CHILDREN),
+static WORD_MANO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euverability"),
         dictgen::InsensitiveStr::Ascii("uevring"),
@@ -105451,12 +105451,12 @@ pub static WORD_MANO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_MANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANN_CHILDREN),
+static WORD_MANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("arisms"),
@@ -105482,12 +105482,12 @@ pub static WORD_MANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANI_CHILDREN),
+static WORD_MANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("facture"),
         dictgen::InsensitiveStr::Ascii("factured"),
@@ -105619,12 +105619,12 @@ pub static WORD_MANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_MANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANG_CHILDREN),
+static WORD_MANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aed"),
         dictgen::InsensitiveStr::Ascii("aement"),
@@ -105664,12 +105664,12 @@ pub static WORD_MANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_MANF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANF_CHILDREN),
+static WORD_MANF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acturer"),
         dictgen::InsensitiveStr::Ascii("iest"),
@@ -105687,12 +105687,12 @@ pub static WORD_MANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_MANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANE_CHILDREN),
+static WORD_MANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agable"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -105740,12 +105740,12 @@ pub static WORD_MANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAND_CHILDREN),
+static WORD_MAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arian"),
         dictgen::InsensitiveStr::Ascii("arijn"),
@@ -105779,12 +105779,12 @@ pub static WORD_MAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANA_CHILDREN),
+static WORD_MANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("drin"),
         dictgen::InsensitiveStr::Ascii("factured"),
@@ -105858,12 +105858,12 @@ pub static WORD_MANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_MAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAM_CHILDREN),
+static WORD_MAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agement"),
         dictgen::InsensitiveStr::Ascii("al"),
@@ -105885,12 +105885,12 @@ pub static WORD_MAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_MAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAL_CHILDREN),
+static WORD_MAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aira"),
         dictgen::InsensitiveStr::Ascii("ariya"),
@@ -105980,12 +105980,12 @@ pub static WORD_MAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_MAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAK_CHILDREN),
+static WORD_MAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAK_CHILDREN),
     value: Some(&["make", "mask"]),
 };
 
-pub static WORD_MAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -106023,23 +106023,23 @@ pub static WORD_MAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MAJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAJ_CHILDREN),
+static WORD_MAJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oroty")],
     values: &[&["majority"]],
     range: 5..=5,
 };
 
-static WORD_MAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAI_CHILDREN),
+static WORD_MAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAI_CHILDREN),
     value: None,
 };
 
-static WORD_MAI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_MAIB_NODE),
     None,
@@ -106068,12 +106068,12 @@ static WORD_MAI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MAIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIT_CHILDREN),
+static WORD_MAIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainance"),
@@ -106091,12 +106091,12 @@ pub static WORD_MAIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MAIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIR_CHILDREN),
+static WORD_MAIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abd"),
         dictgen::InsensitiveStr::Ascii("adb"),
@@ -106107,12 +106107,12 @@ pub static WORD_MAIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MAIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIN_CHILDREN),
+static WORD_MAIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ained"),
         dictgen::InsensitiveStr::Ascii("ainer"),
@@ -106224,23 +106224,23 @@ pub static WORD_MAIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_MAIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIM_CHILDREN),
+static WORD_MAIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("um")],
     values: &[&["maximum"]],
     range: 2..=2,
 };
 
-static WORD_MAIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIL_CHILDREN),
+static WORD_MAIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("formed"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -106251,23 +106251,23 @@ pub static WORD_MAIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_MAID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAID_CHILDREN),
+static WORD_MAID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAID_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("son")],
     values: &[&["madison"]],
     range: 3..=3,
 };
 
-static WORD_MAIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIB_CHILDREN),
+static WORD_MAIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ox"),
@@ -106276,23 +106276,23 @@ pub static WORD_MAIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_MAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAH_CHILDREN),
+static WORD_MAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cine")],
     values: &[&["machine"]],
     range: 4..=4,
 };
 
-static WORD_MAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAG_CHILDREN),
+static WORD_MAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainzes"),
         dictgen::InsensitiveStr::Ascii("asine"),
@@ -106368,12 +106368,12 @@ pub static WORD_MAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAE_CHILDREN),
+static WORD_MAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aningless"),
         dictgen::InsensitiveStr::Ascii("stries"),
@@ -106397,12 +106397,12 @@ pub static WORD_MAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_MAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAD_CHILDREN),
+static WORD_MAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antory"),
         dictgen::InsensitiveStr::Ascii("atory"),
@@ -106422,12 +106422,12 @@ pub static WORD_MAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_MAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAC_CHILDREN),
+static WORD_MAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("arino"),
@@ -106509,12 +106509,12 @@ pub static WORD_MAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_MAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAB_CHILDREN),
+static WORD_MAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ye"),
@@ -106524,12 +106524,12 @@ pub static WORD_MAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_MAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAA_CHILDREN),
+static WORD_MAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ke"),
         dictgen::InsensitiveStr::Ascii("nagement"),
@@ -106547,12 +106547,12 @@ pub static WORD_MAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_L_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_L_CHILDREN),
+static WORD_L_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_L_CHILDREN),
     value: None,
 };
 
-static WORD_L_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_L_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LA_NODE),
     None,
     Some(&WORD_LC_NODE),
@@ -106581,12 +106581,12 @@ static WORD_L_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LY_CHILDREN),
+static WORD_LY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bia"),
         dictgen::InsensitiveStr::Ascii("che"),
@@ -106595,12 +106595,12 @@ pub static WORD_LY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=3,
 };
 
-static WORD_LV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LV_CHILDREN),
+static WORD_LV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LV_CHILDREN),
     value: None,
 };
 
-pub static WORD_LV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eo"),
         dictgen::InsensitiveStr::Ascii("oe"),
@@ -106609,12 +106609,12 @@ pub static WORD_LV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_LU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LU_CHILDREN),
+static WORD_LU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anched"),
         dictgen::InsensitiveStr::Ascii("ancher"),
@@ -106688,23 +106688,23 @@ pub static WORD_LU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_LT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LT_CHILDREN),
+static WORD_LT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eral")],
     values: &[&["literal"]],
     range: 4..=4,
 };
 
-static WORD_LS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LS_CHILDREN),
+static WORD_LS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LS_CHILDREN),
     value: None,
 };
 
-pub static WORD_LS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ip"),
@@ -106724,23 +106724,23 @@ pub static WORD_LS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_LP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LP_CHILDREN),
+static WORD_LP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LP_CHILDREN),
     value: None,
 };
 
-pub static WORD_LP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atform")],
     values: &[&["platform"]],
     range: 6..=6,
 };
 
-static WORD_LO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LO_CHILDREN),
+static WORD_LO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LO_CHILDREN),
     value: None,
 };
 
-static WORD_LO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LOA_NODE),
     Some(&WORD_LOB_NODE),
     Some(&WORD_LOC_NODE),
@@ -106769,34 +106769,34 @@ static WORD_LO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_LOZ_NODE),
 ];
 
-static WORD_LOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOZ_CHILDREN),
+static WORD_LOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onya")],
     values: &[&["lasagna"]],
     range: 4..=4,
 };
 
-static WORD_LOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOY_CHILDREN),
+static WORD_LOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ality")],
     values: &[&["loyalty"]],
     range: 5..=5,
 };
 
-static WORD_LOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOW_CHILDREN),
+static WORD_LOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("case"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -106806,23 +106806,23 @@ pub static WORD_LOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_LOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOV_CHILDREN),
+static WORD_LOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOV_CHILDREN),
     value: Some(&["love"]),
 };
 
-pub static WORD_LOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ley")],
     values: &[&["lovely"]],
     range: 3..=3,
 };
 
-static WORD_LOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOU_CHILDREN),
+static WORD_LOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ieville"),
         dictgen::InsensitiveStr::Ascii("isiania"),
@@ -106846,12 +106846,12 @@ pub static WORD_LOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=8,
 };
 
-static WORD_LOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOT_CHILDREN),
+static WORD_LOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("haringen"),
@@ -106860,12 +106860,12 @@ pub static WORD_LOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_LOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOS_CHILDREN),
+static WORD_LOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -106887,23 +106887,23 @@ pub static WORD_LOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOR_CHILDREN),
+static WORD_LOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eplay")],
     values: &[&["roleplay"]],
     range: 5..=5,
 };
 
-static WORD_LOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOO_CHILDREN),
+static WORD_LOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("back"),
         dictgen::InsensitiveStr::Ascii("backs"),
@@ -106957,12 +106957,12 @@ pub static WORD_LOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LON_CHILDREN),
+static WORD_LON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LON_CHILDREN),
     value: None,
 };
 
-pub static WORD_LON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -107018,12 +107018,12 @@ pub static WORD_LON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_LOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOL_CHILDREN),
+static WORD_LOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("erant"),
@@ -107034,12 +107034,12 @@ pub static WORD_LOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOK_CHILDREN),
+static WORD_LOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOK_CHILDREN),
     value: Some(&["look"]),
 };
 
-pub static WORD_LOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ale"),
@@ -107057,12 +107057,12 @@ pub static WORD_LOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_LOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOI_CHILDREN),
+static WORD_LOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("gns"),
@@ -107073,12 +107073,12 @@ pub static WORD_LOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOG_CHILDREN),
+static WORD_LOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arighmic"),
         dictgen::InsensitiveStr::Ascii("arithimic"),
@@ -107154,12 +107154,12 @@ pub static WORD_LOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_LOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOE_CHILDREN),
+static WORD_LOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nard"),
         dictgen::InsensitiveStr::Ascii("pard"),
@@ -107169,12 +107169,12 @@ pub static WORD_LOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_LOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOD_CHILDREN),
+static WORD_LOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOD_CHILDREN),
     value: Some(&["load"]),
 };
 
-pub static WORD_LOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("aer"),
@@ -107194,12 +107194,12 @@ pub static WORD_LOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_LOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOC_CHILDREN),
+static WORD_LOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -107295,12 +107295,12 @@ pub static WORD_LOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_LOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOB_CHILDREN),
+static WORD_LOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("byistes"),
         dictgen::InsensitiveStr::Ascii("bysits"),
@@ -107309,12 +107309,12 @@ pub static WORD_LOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_LOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOA_CHILDREN),
+static WORD_LOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ader"),
         dictgen::InsensitiveStr::Ascii("cal"),
@@ -107346,12 +107346,12 @@ pub static WORD_LOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_LN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LN_CHILDREN),
+static WORD_LN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("guage"),
         dictgen::InsensitiveStr::Ascii("guages"),
@@ -107362,12 +107362,12 @@ pub static WORD_LN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_LM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LM_CHILDREN),
+static WORD_LM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LM_CHILDREN),
     value: None,
 };
 
-pub static WORD_LM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ited"),
         dictgen::InsensitiveStr::Ascii("its"),
@@ -107376,12 +107376,12 @@ pub static WORD_LM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_LL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LL_CHILDREN),
+static WORD_LL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LL_CHILDREN),
     value: None,
 };
 
-pub static WORD_LL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ike"),
         dictgen::InsensitiveStr::Ascii("inear"),
@@ -107392,23 +107392,23 @@ pub static WORD_LL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_LK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LK_CHILDREN),
+static WORD_LK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LK_CHILDREN),
     value: None,
 };
 
-pub static WORD_LK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["like"]],
     range: 1..=1,
 };
 
-static WORD_LI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LI_CHILDREN),
+static WORD_LI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LI_CHILDREN),
     value: None,
 };
 
-static WORD_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LIA_NODE),
     Some(&WORD_LIB_NODE),
     Some(&WORD_LIC_NODE),
@@ -107437,12 +107437,12 @@ static WORD_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_LIZ_NODE),
 ];
 
-static WORD_LIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIZ_CHILDREN),
+static WORD_LIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ens"),
         dictgen::InsensitiveStr::Ascii("ense"),
@@ -107452,12 +107452,12 @@ pub static WORD_LIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_LIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIV_CHILDREN),
+static WORD_LIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eatream"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -107495,12 +107495,12 @@ pub static WORD_LIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIU_CHILDREN),
+static WORD_LIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etenant"),
         dictgen::InsensitiveStr::Ascii("ke"),
@@ -107509,12 +107509,12 @@ pub static WORD_LIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIT_CHILDREN),
+static WORD_LIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aral"),
         dictgen::InsensitiveStr::Ascii("arally"),
@@ -107642,12 +107642,12 @@ pub static WORD_LIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_LIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIS_CHILDREN),
+static WORD_LIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cence"),
         dictgen::InsensitiveStr::Ascii("cense"),
@@ -107717,12 +107717,12 @@ pub static WORD_LIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_LIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIQ_CHILDREN),
+static WORD_LIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iuds"),
         dictgen::InsensitiveStr::Ascii("uidas"),
@@ -107740,12 +107740,12 @@ pub static WORD_LIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_LIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIP_CHILDREN),
+static WORD_LIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pizaner"),
         dictgen::InsensitiveStr::Ascii("stics"),
@@ -107754,23 +107754,23 @@ pub static WORD_LIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_LIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIO_CHILDREN),
+static WORD_LIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("usville")],
     values: &[&["louisville"]],
     range: 7..=7,
 };
 
-static WORD_LIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIN_CHILDREN),
+static WORD_LIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("ar"),
@@ -107870,12 +107870,12 @@ pub static WORD_LIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_LIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIM_CHILDREN),
+static WORD_LIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iation"),
         dictgen::InsensitiveStr::Ascii("iations"),
@@ -107971,23 +107971,23 @@ pub static WORD_LIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_LIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIL_CHILDREN),
+static WORD_LIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eral")],
     values: &[&["literal"]],
     range: 4..=4,
 };
 
-static WORD_LIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIK_CHILDREN),
+static WORD_LIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIK_CHILDREN),
     value: Some(&["like", "lick", "link"]),
 };
 
-pub static WORD_LIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebale"),
         dictgen::InsensitiveStr::Ascii("eley"),
@@ -108017,23 +108017,23 @@ pub static WORD_LIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_LII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LII_CHILDREN),
+static WORD_LII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LII_CHILDREN),
     value: None,
 };
 
-pub static WORD_LII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tle")],
     values: &[&["little"]],
     range: 3..=3,
 };
 
-static WORD_LIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIG_CHILDREN),
+static WORD_LIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hbar"),
@@ -108149,12 +108149,12 @@ pub static WORD_LIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_LIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIF_CHILDREN),
+static WORD_LIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceycle"),
         dictgen::InsensitiveStr::Ascii("ecicle"),
@@ -108200,12 +108200,12 @@ pub static WORD_LIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIE_CHILDREN),
+static WORD_LIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("brals"),
         dictgen::InsensitiveStr::Ascii("cester"),
@@ -108259,12 +108259,12 @@ pub static WORD_LIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_LIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIC_CHILDREN),
+static WORD_LIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -108322,12 +108322,12 @@ pub static WORD_LIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_LIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LIB_CHILDREN),
+static WORD_LIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LIB_CHILDREN),
     value: None,
 };
 
-static WORD_LIB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LIB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LIBA_NODE),
     None,
     None,
@@ -108356,12 +108356,12 @@ static WORD_LIB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LIBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBR_CHILDREN),
+static WORD_LIBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBR_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aarie"),
         dictgen::InsensitiveStr::Ascii("aaries"),
@@ -108463,34 +108463,34 @@ pub static WORD_LIBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_LIBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBL_CHILDREN),
+static WORD_LIBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["libel", "liable"]],
     range: 1..=1,
 };
 
-static WORD_LIBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBI_CHILDREN),
+static WORD_LIBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tarianisn")],
     values: &[&["libertarianism"]],
     range: 9..=9,
 };
 
-static WORD_LIBG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBG_CHILDREN),
+static WORD_LIBG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("uistic"),
@@ -108500,12 +108500,12 @@ pub static WORD_LIBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_LIBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBE_CHILDREN),
+static WORD_LIBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ll"),
         dictgen::InsensitiveStr::Ascii("racion"),
@@ -108617,12 +108617,12 @@ pub static WORD_LIBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_LIBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBA_CHILDREN),
+static WORD_LIBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rary"),
         dictgen::InsensitiveStr::Ascii("ries"),
@@ -108632,12 +108632,12 @@ pub static WORD_LIBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_LIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIA_CHILDREN),
+static WORD_LIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blity"),
         dictgen::InsensitiveStr::Ascii("res"),
@@ -108659,34 +108659,34 @@ pub static WORD_LIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_LG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LG_CHILDREN),
+static WORD_LG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eacy")],
     values: &[&["legacy"]],
     range: 4..=4,
 };
 
-static WORD_LF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LF_CHILDREN),
+static WORD_LF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LF_CHILDREN),
     value: None,
 };
 
-pub static WORD_LF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iesteal")],
     values: &[&["lifesteal"]],
     range: 7..=7,
 };
 
-static WORD_LE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LE_CHILDREN),
+static WORD_LE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LE_CHILDREN),
     value: None,
 };
 
-static WORD_LE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LEA_NODE),
     Some(&WORD_LEB_NODE),
     Some(&WORD_LEC_NODE),
@@ -108715,12 +108715,12 @@ static WORD_LE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEY_CHILDREN),
+static WORD_LEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -108731,12 +108731,12 @@ pub static WORD_LEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_LEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEX_CHILDREN),
+static WORD_LEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("icographycally"),
@@ -108760,12 +108760,12 @@ pub static WORD_LEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=14,
 };
 
-static WORD_LEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEW_CHILDREN),
+static WORD_LEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEW_CHILDREN),
     value: Some(&["dew", "hew", "lieu", "sew"]),
 };
 
-pub static WORD_LEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chemia"),
         dictgen::InsensitiveStr::Ascii("ow"),
@@ -108783,12 +108783,12 @@ pub static WORD_LEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEV_CHILDREN),
+static WORD_LEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aithan"),
@@ -108834,12 +108834,12 @@ pub static WORD_LEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_LEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEU_CHILDREN),
+static WORD_LEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itenant"),
         dictgen::InsensitiveStr::Ascii("tenant"),
@@ -108848,12 +108848,12 @@ pub static WORD_LEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_LET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LET_CHILDREN),
+static WORD_LET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LET_CHILDREN),
     value: None,
 };
 
-pub static WORD_LET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gitimate"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -108864,12 +108864,12 @@ pub static WORD_LET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_LES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LES_CHILDREN),
+static WORD_LES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LES_CHILDREN),
     value: None,
 };
 
-pub static WORD_LES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bain"),
         dictgen::InsensitiveStr::Ascii("bains"),
@@ -108901,12 +108901,12 @@ pub static WORD_LES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_LER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LER_CHILDREN),
+static WORD_LER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LER_CHILDREN),
     value: None,
 };
 
-pub static WORD_LER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("aned"),
@@ -108926,12 +108926,12 @@ pub static WORD_LER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_LEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEP_CHILDREN),
+static WORD_LEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -108955,12 +108955,12 @@ pub static WORD_LEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_LEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEN_CHILDREN),
+static WORD_LEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("gedaries"),
@@ -109040,12 +109040,12 @@ pub static WORD_LEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_LEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEM_CHILDREN),
+static WORD_LEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("osine"),
         dictgen::InsensitiveStr::Ascii("osines"),
@@ -109054,12 +109054,12 @@ pub static WORD_LEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_LEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEI_CHILDREN),
+static WORD_LEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bnitz"),
         dictgen::InsensitiveStr::Ascii("ghtweight"),
@@ -109075,12 +109075,12 @@ pub static WORD_LEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_LEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LEG_CHILDREN),
+static WORD_LEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LEG_CHILDREN),
     value: None,
 };
 
-static WORD_LEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LEG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LEGA_NODE),
     None,
     None,
@@ -109109,12 +109109,12 @@ static WORD_LEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LEGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGT_CHILDREN),
+static WORD_LEGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGT_CHILDREN),
     value: Some(&["left", "legit"]),
 };
 
-pub static WORD_LEGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hs"),
@@ -109123,23 +109123,23 @@ pub static WORD_LEGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_LEGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGO_CHILDREN),
+static WORD_LEGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGO_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ins")],
     values: &[&["legions"]],
     range: 3..=3,
 };
 
-static WORD_LEGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGN_CHILDREN),
+static WORD_LEGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edaries"),
         dictgen::InsensitiveStr::Ascii("edary"),
@@ -109157,12 +109157,12 @@ pub static WORD_LEGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_LEGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGI_CHILDREN),
+static WORD_LEGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lsation"),
         dictgen::InsensitiveStr::Ascii("mitacy"),
@@ -109250,12 +109250,12 @@ pub static WORD_LEGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_LEGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGH_CHILDREN),
+static WORD_LEGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGH_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -109264,12 +109264,12 @@ pub static WORD_LEGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_LEGG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGG_CHILDREN),
+static WORD_LEGG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acies"),
         dictgen::InsensitiveStr::Ascii("acy"),
@@ -109278,12 +109278,12 @@ pub static WORD_LEGG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_LEGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGE_CHILDREN),
+static WORD_LEGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("nadries"),
@@ -109315,12 +109315,12 @@ pub static WORD_LEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_LEGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGA_CHILDREN),
+static WORD_LEGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -109352,12 +109352,12 @@ pub static WORD_LEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_LEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEF_CHILDREN),
+static WORD_LEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itst"),
         dictgen::InsensitiveStr::Ascii("itsts"),
@@ -109375,12 +109375,12 @@ pub static WORD_LEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_LEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEE_CHILDREN),
+static WORD_LEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gs"),
@@ -109402,12 +109402,12 @@ pub static WORD_LEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEC_CHILDREN),
+static WORD_LEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eister"),
         dictgen::InsensitiveStr::Ascii("iester"),
@@ -109425,23 +109425,23 @@ pub static WORD_LEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_LEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEB_CHILDREN),
+static WORD_LEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("anesse")],
     values: &[&["lebanese"]],
     range: 6..=6,
 };
 
-static WORD_LEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEA_CHILDREN),
+static WORD_LEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -109533,12 +109533,12 @@ pub static WORD_LEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_LC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LC_CHILDREN),
+static WORD_LC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oal"),
         dictgen::InsensitiveStr::Ascii("oally"),
@@ -109556,12 +109556,12 @@ pub static WORD_LC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_LA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LA_CHILDREN),
+static WORD_LA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LA_CHILDREN),
     value: None,
 };
 
-static WORD_LA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_LAB_NODE),
     Some(&WORD_LAC_NODE),
@@ -109590,12 +109590,12 @@ static WORD_LA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_LAZ_NODE),
 ];
 
-static WORD_LAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAZ_CHILDREN),
+static WORD_LAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("iliy"),
@@ -109605,12 +109605,12 @@ pub static WORD_LAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_LAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAY_CHILDREN),
+static WORD_LAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("brinth"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -109644,23 +109644,23 @@ pub static WORD_LAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_LAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAW_CHILDREN),
+static WORD_LAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ernce")],
     values: &[&["lawrence"]],
     range: 5..=5,
 };
 
-static WORD_LAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAV_CHILDREN),
+static WORD_LAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -109686,12 +109686,12 @@ pub static WORD_LAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_LAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAU_CHILDREN),
+static WORD_LAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -109751,12 +109751,12 @@ pub static WORD_LAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_LAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAT_CHILDREN),
+static WORD_LAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecny"),
         dictgen::InsensitiveStr::Ascii("enciy"),
@@ -109804,12 +109804,12 @@ pub static WORD_LAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAS_CHILDREN),
+static WORD_LAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agnea"),
         dictgen::InsensitiveStr::Ascii("agnia"),
@@ -109835,12 +109835,12 @@ pub static WORD_LAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_LAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAR_CHILDREN),
+static WORD_LAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eady"),
         dictgen::InsensitiveStr::Ascii("egly"),
@@ -109884,12 +109884,12 @@ pub static WORD_LAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAO_CHILDREN),
+static WORD_LAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -109913,12 +109913,12 @@ pub static WORD_LAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_LAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LAN_CHILDREN),
+static WORD_LAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LAN_CHILDREN),
     value: None,
 };
 
-static WORD_LAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LANA_NODE),
     None,
     None,
@@ -109947,12 +109947,12 @@ static WORD_LAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LANU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANU_CHILDREN),
+static WORD_LANU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -109978,23 +109978,23 @@ pub static WORD_LANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_LANT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANT_CHILDREN),
+static WORD_LANT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ren")],
     values: &[&["lantern"]],
     range: 3..=3,
 };
 
-static WORD_LANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANN_CHILDREN),
+static WORD_LANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asters"),
         dictgen::InsensitiveStr::Ascii("esters"),
@@ -110014,23 +110014,23 @@ pub static WORD_LANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_LANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANI_CHILDREN),
+static WORD_LANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ch")],
     values: &[&["launch"]],
     range: 2..=2,
 };
 
-static WORD_LANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LANG_CHILDREN),
+static WORD_LANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LANG_CHILDREN),
     value: None,
 };
 
-static WORD_LANG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LANG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LANGA_NODE),
     None,
     None,
@@ -110059,12 +110059,12 @@ static WORD_LANG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LANGY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGY_CHILDREN),
+static WORD_LANGY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -110073,12 +110073,12 @@ pub static WORD_LANGY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_LANGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGU_CHILDREN),
+static WORD_LANGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -110182,12 +110182,12 @@ pub static WORD_LANGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_LANGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGT_CHILDREN),
+static WORD_LANGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hs"),
@@ -110196,12 +110196,12 @@ pub static WORD_LANGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_LANGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGN_CHILDREN),
+static WORD_LANGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("guage"),
         dictgen::InsensitiveStr::Ascii("guages"),
@@ -110210,12 +110210,12 @@ pub static WORD_LANGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_LANGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGI_CHILDREN),
+static WORD_LANGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -110224,12 +110224,12 @@ pub static WORD_LANGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_LANGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGH_CHILDREN),
+static WORD_LANGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGH_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -110238,12 +110238,12 @@ pub static WORD_LANGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_LANGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGE_CHILDREN),
+static WORD_LANGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rie"),
         dictgen::InsensitiveStr::Ascii("rray"),
@@ -110259,12 +110259,12 @@ pub static WORD_LANGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_LANGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGA_CHILDREN),
+static WORD_LANGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("ges"),
@@ -110286,12 +110286,12 @@ pub static WORD_LANGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_LAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAND_CHILDREN),
+static WORD_LAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acapes"),
         dictgen::InsensitiveStr::Ascii("ingers"),
@@ -110319,12 +110319,12 @@ pub static WORD_LAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_LANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANA_CHILDREN),
+static WORD_LANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("guage"),
         dictgen::InsensitiveStr::Ascii("guge"),
@@ -110346,12 +110346,12 @@ pub static WORD_LANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_LAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAM_CHILDREN),
+static WORD_LAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("da"),
         dictgen::InsensitiveStr::Ascii("das"),
@@ -110361,23 +110361,23 @@ pub static WORD_LAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_LAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAI_CHILDREN),
+static WORD_LAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["later"]],
     range: 3..=3,
 };
 
-static WORD_LAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAG_CHILDREN),
+static WORD_LAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acies"),
         dictgen::InsensitiveStr::Ascii("acy"),
@@ -110403,34 +110403,34 @@ pub static WORD_LAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAF_CHILDREN),
+static WORD_LAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAF_CHILDREN),
     value: Some(&["kaf", "kaph", "lac", "lad", "lag", "laugh", "leaf", "loaf"]),
 };
 
-pub static WORD_LAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_LAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAE_CHILDREN),
+static WORD_LAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["later", "layer"]],
     range: 1..=1,
 };
 
-static WORD_LAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAC_CHILDREN),
+static WORD_LAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kbuster"),
         dictgen::InsensitiveStr::Ascii("ker"),
@@ -110460,12 +110460,12 @@ pub static WORD_LAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_LAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAB_CHILDREN),
+static WORD_LAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alled"),
         dictgen::InsensitiveStr::Ascii("arotory"),
@@ -110539,12 +110539,12 @@ pub static WORD_LAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_K_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_K_CHILDREN),
+static WORD_K_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_K_CHILDREN),
     value: None,
 };
 
-static WORD_K_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_K_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_KA_NODE),
     None,
     None,
@@ -110573,12 +110573,12 @@ static WORD_K_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_KY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KY_CHILDREN),
+static WORD_KY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KY_CHILDREN),
     value: None,
 };
 
-pub static WORD_KY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebosh"),
         dictgen::InsensitiveStr::Ascii("eboshed"),
@@ -110598,12 +110598,12 @@ pub static WORD_KY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_KW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KW_CHILDREN),
+static WORD_KW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KW_CHILDREN),
     value: None,
 };
 
-pub static WORD_KW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eyword"),
         dictgen::InsensitiveStr::Ascii("no"),
@@ -110621,12 +110621,12 @@ pub static WORD_KW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_KU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KU_CHILDREN),
+static WORD_KU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KU_CHILDREN),
     value: None,
 };
 
-pub static WORD_KU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("benates"),
         dictgen::InsensitiveStr::Ascii("benernetes"),
@@ -110676,23 +110676,23 @@ pub static WORD_KU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=10,
 };
 
-static WORD_KT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KT_CHILDREN),
+static WORD_KT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KT_CHILDREN),
     value: None,
 };
 
-pub static WORD_KT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ichen")],
     values: &[&["kitchen"]],
     range: 5..=5,
 };
 
-static WORD_KR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KR_CHILDREN),
+static WORD_KR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KR_CHILDREN),
     value: None,
 };
 
-pub static WORD_KR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ankenstein"),
         dictgen::InsensitiveStr::Ascii("esh"),
@@ -110740,12 +110740,12 @@ pub static WORD_KR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_KO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KO_CHILDREN),
+static WORD_KO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KO_CHILDREN),
     value: None,
 };
 
-pub static WORD_KO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("calized"),
         dictgen::InsensitiveStr::Ascii("llaboration"),
@@ -110829,12 +110829,12 @@ pub static WORD_KO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_KN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KN_CHILDREN),
+static WORD_KN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KN_CHILDREN),
     value: None,
 };
 
-pub static WORD_KN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arl"),
         dictgen::InsensitiveStr::Ascii("arled"),
@@ -110958,23 +110958,23 @@ pub static WORD_KN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_KM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KM_CHILDREN),
+static WORD_KM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KM_CHILDREN),
     value: None,
 };
 
-pub static WORD_KM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ow")],
     values: &[&["know"]],
     range: 2..=2,
 };
 
-static WORD_KL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KL_CHILDREN),
+static WORD_KL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KL_CHILDREN),
     value: None,
 };
 
-pub static WORD_KL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enex"),
         dictgen::InsensitiveStr::Ascii("ick"),
@@ -110992,23 +110992,23 @@ pub static WORD_KL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_KK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KK_CHILDREN),
+static WORD_KK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KK_CHILDREN),
     value: None,
 };
 
-pub static WORD_KK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("now")],
     values: &[&["know"]],
     range: 3..=3,
 };
 
-static WORD_KI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_KI_CHILDREN),
+static WORD_KI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_KI_CHILDREN),
     value: None,
 };
 
-static WORD_KI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_KI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_KIB_NODE),
     Some(&WORD_KIC_NODE),
@@ -111037,12 +111037,12 @@ static WORD_KI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_KIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIY_CHILDREN),
+static WORD_KIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("acked"),
@@ -111062,12 +111062,12 @@ pub static WORD_KIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_KIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIT_CHILDREN),
+static WORD_KIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ches"),
         dictgen::InsensitiveStr::Ascii("ites"),
@@ -111077,12 +111077,12 @@ pub static WORD_KIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_KIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIN_CHILDREN),
+static WORD_KIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dapped"),
         dictgen::InsensitiveStr::Ascii("dapping"),
@@ -111124,12 +111124,12 @@ pub static WORD_KIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_KIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIM_CHILDREN),
+static WORD_KIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("era"),
         dictgen::InsensitiveStr::Ascii("eric"),
@@ -111153,12 +111153,12 @@ pub static WORD_KIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_KIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIL_CHILDREN),
+static WORD_KIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lingest"),
         dictgen::InsensitiveStr::Ascii("lins"),
@@ -111182,12 +111182,12 @@ pub static WORD_KIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_KIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIG_CHILDREN),
+static WORD_KIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hbosh"),
         dictgen::InsensitiveStr::Ascii("hboshed"),
@@ -111198,12 +111198,12 @@ pub static WORD_KIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_KID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KID_CHILDREN),
+static WORD_KID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KID_CHILDREN),
     value: None,
 };
 
-pub static WORD_KID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("knap"),
         dictgen::InsensitiveStr::Ascii("knapped"),
@@ -111239,12 +111239,12 @@ pub static WORD_KID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_KIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIC_CHILDREN),
+static WORD_KIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kstarer"),
         dictgen::InsensitiveStr::Ascii("kstartr"),
@@ -111262,12 +111262,12 @@ pub static WORD_KIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_KIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIB_CHILDREN),
+static WORD_KIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("utz"),
         dictgen::InsensitiveStr::Ascii("utzes"),
@@ -111277,12 +111277,12 @@ pub static WORD_KIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_KE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_KE_CHILDREN),
+static WORD_KE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_KE_CHILDREN),
     value: None,
 };
 
-static WORD_KE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_KE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_KEB_NODE),
     None,
@@ -111311,12 +111311,12 @@ static WORD_KE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_KEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEY_CHILDREN),
+static WORD_KEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baord"),
         dictgen::InsensitiveStr::Ascii("baords"),
@@ -111404,12 +111404,12 @@ pub static WORD_KEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_KEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEW_CHILDREN),
+static WORD_KEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ord"),
         dictgen::InsensitiveStr::Ascii("ords"),
@@ -111420,23 +111420,23 @@ pub static WORD_KEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_KET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KET_CHILDREN),
+static WORD_KET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KET_CHILDREN),
     value: Some(&["kept", "key"]),
 };
 
-pub static WORD_KET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("maine")],
     values: &[&["ketamine"]],
     range: 5..=5,
 };
 
-static WORD_KER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KER_CHILDREN),
+static WORD_KER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KER_CHILDREN),
     value: None,
 };
 
-pub static WORD_KER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enl"),
         dictgen::InsensitiveStr::Ascii("enls"),
@@ -111460,12 +111460,12 @@ pub static WORD_KER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_KEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEP_CHILDREN),
+static WORD_KEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oint"),
         dictgen::InsensitiveStr::Ascii("oints"),
@@ -111483,12 +111483,12 @@ pub static WORD_KEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_KEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEN_CHILDREN),
+static WORD_KEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("els"),
@@ -111522,12 +111522,12 @@ pub static WORD_KEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_KEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEE_CHILDREN),
+static WORD_KEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alive"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -111547,23 +111547,23 @@ pub static WORD_KEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_KEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEB_CHILDREN),
+static WORD_KEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oard")],
     values: &[&["keyboard"]],
     range: 4..=4,
 };
 
-static WORD_KA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KA_CHILDREN),
+static WORD_KA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KA_CHILDREN),
     value: None,
 };
 
-pub static WORD_KA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckie"),
         dictgen::InsensitiveStr::Ascii("ckies"),
@@ -111603,12 +111603,12 @@ pub static WORD_KA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_J_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_J_CHILDREN),
+static WORD_J_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_J_CHILDREN),
     value: None,
 };
 
-static WORD_J_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_J_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_JA_NODE),
     None,
     None,
@@ -111637,12 +111637,12 @@ static WORD_J_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_JU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_JU_CHILDREN),
+static WORD_JU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_JU_CHILDREN),
     value: None,
 };
 
-static WORD_JU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_JU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_JUA_NODE),
     None,
     None,
@@ -111671,12 +111671,12 @@ static WORD_JU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_JUX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUX_CHILDREN),
+static WORD_JUX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUX_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tification"),
@@ -111698,12 +111698,12 @@ pub static WORD_JUX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_JUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUV_CHILDREN),
+static WORD_JUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eline"),
         dictgen::InsensitiveStr::Ascii("enille"),
@@ -111714,12 +111714,12 @@ pub static WORD_JUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_JUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUS_CHILDREN),
+static WORD_JUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUS_CHILDREN),
     value: Some(&["just"]),
 };
 
-pub static WORD_JUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("itfication"),
@@ -111771,12 +111771,12 @@ pub static WORD_JUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_JUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUR_CHILDREN),
+static WORD_JUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idisction"),
         dictgen::InsensitiveStr::Ascii("isdiccion"),
@@ -111832,12 +111832,12 @@ pub static WORD_JUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_JUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUP_CHILDREN),
+static WORD_JUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tier"),
         dictgen::InsensitiveStr::Ascii("yther"),
@@ -111846,12 +111846,12 @@ pub static WORD_JUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_JUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUN_CHILDREN),
+static WORD_JUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("glig"),
         dictgen::InsensitiveStr::Ascii("glign"),
@@ -111862,12 +111862,12 @@ pub static WORD_JUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_JUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUM_CHILDREN),
+static WORD_JUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("oed"),
@@ -111878,34 +111878,34 @@ pub static WORD_JUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_JUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUL_CHILDREN),
+static WORD_JUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("i")],
     values: &[&["july"]],
     range: 1..=1,
 };
 
-static WORD_JUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUI_CHILDREN),
+static WORD_JUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pter")],
     values: &[&["jupiter"]],
     range: 4..=4,
 };
 
-static WORD_JUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUG_CHILDREN),
+static WORD_JUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dement"),
         dictgen::InsensitiveStr::Ascii("demental"),
@@ -111949,12 +111949,12 @@ pub static WORD_JUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_JUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUD_CHILDREN),
+static WORD_JUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aisim"),
         dictgen::InsensitiveStr::Ascii("asim"),
@@ -111996,12 +111996,12 @@ pub static WORD_JUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_JUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUA_CHILDREN),
+static WORD_JUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daism"),
         dictgen::InsensitiveStr::Ascii("dism"),
@@ -112010,12 +112010,12 @@ pub static WORD_JUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_JS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JS_CHILDREN),
+static WORD_JS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JS_CHILDREN),
     value: None,
 };
 
-pub static WORD_JS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cipt"),
         dictgen::InsensitiveStr::Ascii("tu"),
@@ -112026,12 +112026,12 @@ pub static WORD_JS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_JP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JP_CHILDREN),
+static WORD_JP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JP_CHILDREN),
     value: None,
 };
 
-pub static WORD_JP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -112040,12 +112040,12 @@ pub static WORD_JP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_JO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JO_CHILDREN),
+static WORD_JO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JO_CHILDREN),
     value: None,
 };
 
-pub static WORD_JO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anthan"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -112165,45 +112165,45 @@ pub static WORD_JO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=13,
 };
 
-static WORD_JN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JN_CHILDREN),
+static WORD_JN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JN_CHILDREN),
     value: None,
 };
 
-pub static WORD_JN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iw")],
     values: &[&["know"]],
     range: 2..=2,
 };
 
-static WORD_JK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JK_CHILDREN),
+static WORD_JK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JK_CHILDREN),
     value: None,
 };
 
-pub static WORD_JK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["jdk"]],
     range: 1..=1,
 };
 
-static WORD_JJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JJ_CHILDREN),
+static WORD_JJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_JJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ust")],
     values: &[&["just"]],
     range: 3..=3,
 };
 
-static WORD_JI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JI_CHILDREN),
+static WORD_JI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JI_CHILDREN),
     value: None,
 };
 
-pub static WORD_JI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("st"),
@@ -112214,23 +112214,23 @@ pub static WORD_JI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_JH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JH_CHILDREN),
+static WORD_JH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JH_CHILDREN),
     value: None,
 };
 
-pub static WORD_JH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ondoe")],
     values: &[&["johndoe"]],
     range: 5..=5,
 };
 
-static WORD_JE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JE_CHILDREN),
+static WORD_JE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JE_CHILDREN),
     value: None,
 };
 
-pub static WORD_JE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apardy"),
         dictgen::InsensitiveStr::Ascii("fferry"),
@@ -112304,12 +112304,12 @@ pub static WORD_JE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_JA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JA_CHILDREN),
+static WORD_JA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JA_CHILDREN),
     value: None,
 };
 
-pub static WORD_JA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckonsville"),
         dictgen::InsensitiveStr::Ascii("cksonvile"),
@@ -112427,12 +112427,12 @@ pub static WORD_JA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_I_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_I_CHILDREN),
+static WORD_I_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_I_CHILDREN),
     value: None,
 };
 
-static WORD_I_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_I_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IA_NODE),
     Some(&WORD_IB_NODE),
     Some(&WORD_IC_NODE),
@@ -112461,23 +112461,23 @@ static WORD_I_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IY_CHILDREN),
+static WORD_IY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IY_CHILDREN),
     value: Some(&["it"]),
 };
 
-pub static WORD_IY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_IW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IW_CHILDREN),
+static WORD_IW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IW_CHILDREN),
     value: None,
 };
 
-pub static WORD_IW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ht"),
         dictgen::InsensitiveStr::Ascii("ithout"),
@@ -112488,12 +112488,12 @@ pub static WORD_IW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_IV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IV_CHILDREN),
+static WORD_IV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IV_CHILDREN),
     value: None,
 };
 
-pub static WORD_IV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alid"),
         dictgen::InsensitiveStr::Ascii("entory"),
@@ -112515,23 +112515,23 @@ pub static WORD_IV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_IU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IU_CHILDREN),
+static WORD_IU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IU_CHILDREN),
     value: None,
 };
 
-pub static WORD_IU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nior")],
     values: &[&["junior"]],
     range: 4..=4,
 };
 
-static WORD_IT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IT_CHILDREN),
+static WORD_IT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IT_CHILDREN),
     value: None,
 };
 
-static WORD_IT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ITA_NODE),
     None,
     None,
@@ -112560,12 +112560,12 @@ static WORD_IT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ITT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITT_CHILDREN),
+static WORD_ITT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erable"),
         dictgen::InsensitiveStr::Ascii("erate"),
@@ -112593,12 +112593,12 @@ pub static WORD_ITT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_ITS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITS_CHILDREN),
+static WORD_ITS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ef"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -112626,12 +112626,12 @@ pub static WORD_ITS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ITN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITN_CHILDREN),
+static WORD_ITN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erest"),
         dictgen::InsensitiveStr::Ascii("erface"),
@@ -112667,12 +112667,12 @@ pub static WORD_ITN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_ITM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITM_CHILDREN),
+static WORD_ITM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -112681,12 +112681,12 @@ pub static WORD_ITM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_ITI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITI_CHILDREN),
+static WORD_ITI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alise"),
         dictgen::InsensitiveStr::Ascii("alised"),
@@ -112712,12 +112712,12 @@ pub static WORD_ITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_ITH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITH_CHILDREN),
+static WORD_ITH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eir"),
@@ -112727,12 +112727,12 @@ pub static WORD_ITH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_ITE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITE_CHILDREN),
+static WORD_ITE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arates"),
         dictgen::InsensitiveStr::Ascii("artor"),
@@ -112850,12 +112850,12 @@ pub static WORD_ITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ITA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITA_CHILDREN),
+static WORD_ITA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lains"),
         dictgen::InsensitiveStr::Ascii("lianas"),
@@ -112873,12 +112873,12 @@ pub static WORD_ITA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_IS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IS_CHILDREN),
+static WORD_IS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IS_CHILDREN),
     value: None,
 };
 
-static WORD_IS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ISA_NODE),
     None,
     Some(&WORD_ISC_NODE),
@@ -112907,12 +112907,12 @@ static WORD_IS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ISU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISU_CHILDREN),
+static WORD_ISU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -112922,12 +112922,12 @@ pub static WORD_ISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_IST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IST_CHILDREN),
+static WORD_IST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IST_CHILDREN),
     value: Some(&["is", "it", "its", "sit", "list"]),
 };
 
-pub static WORD_IST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alling"),
         dictgen::InsensitiveStr::Ascii("ambul"),
@@ -112959,12 +112959,12 @@ pub static WORD_IST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ISS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISS_CHILDREN),
+static WORD_ISS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -112994,12 +112994,12 @@ pub static WORD_ISS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ISR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISR_CHILDREN),
+static WORD_ISR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeliens"),
         dictgen::InsensitiveStr::Ascii("aelies"),
@@ -113027,12 +113027,12 @@ pub static WORD_ISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_ISP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISP_CHILDREN),
+static WORD_ISP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atches"),
         dictgen::InsensitiveStr::Ascii("lay"),
@@ -113042,12 +113042,12 @@ pub static WORD_ISP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_ISO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISO_CHILDREN),
+static WORD_ISO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("latie"),
         dictgen::InsensitiveStr::Ascii("loated"),
@@ -113057,12 +113057,12 @@ pub static WORD_ISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_ISN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISN_CHILDREN),
+static WORD_ISN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("piron"),
@@ -113108,12 +113108,12 @@ pub static WORD_ISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_ISM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISM_CHILDREN),
+static WORD_ISM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alist"),
         dictgen::InsensitiveStr::Ascii("as"),
@@ -113122,12 +113122,12 @@ pub static WORD_ISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ISL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISL_CHILDREN),
+static WORD_ISL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adn"),
         dictgen::InsensitiveStr::Ascii("amisist"),
@@ -113167,23 +113167,23 @@ pub static WORD_ISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ISI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISI_CHILDREN),
+static WORD_ISI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("milar")],
     values: &[&["similar"]],
     range: 5..=5,
 };
 
-static WORD_ISE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISE_CHILDREN),
+static WORD_ISE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lf"),
         dictgen::InsensitiveStr::Ascii("lfe"),
@@ -113194,23 +113194,23 @@ pub static WORD_ISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ISD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISD_CHILDREN),
+static WORD_ISD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("efinitely")],
     values: &[&["indefinitely"]],
     range: 9..=9,
 };
 
-static WORD_ISC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISC_CHILDREN),
+static WORD_ISC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onnection"),
         dictgen::InsensitiveStr::Ascii("rated"),
@@ -113219,12 +113219,12 @@ pub static WORD_ISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_ISA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISA_CHILDREN),
+static WORD_ISA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lha"),
         dictgen::InsensitiveStr::Ascii("lmic"),
@@ -113246,12 +113246,12 @@ pub static WORD_ISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_IR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IR_CHILDREN),
+static WORD_IR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IR_CHILDREN),
     value: None,
 };
 
-static WORD_IR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IRA_NODE),
     None,
     None,
@@ -113280,12 +113280,12 @@ static WORD_IR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRR_CHILDREN),
+static WORD_IRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acional"),
         dictgen::InsensitiveStr::Ascii("adate"),
@@ -113417,12 +113417,12 @@ pub static WORD_IRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_IRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRO_CHILDREN),
+static WORD_IRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("namn"),
         dictgen::InsensitiveStr::Ascii("ncially"),
@@ -113438,23 +113438,23 @@ pub static WORD_IRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_IRL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRL_CHILDREN),
+static WORD_IRL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRL_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eand")],
     values: &[&["ireland"]],
     range: 4..=4,
 };
 
-static WORD_IRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRI_CHILDREN),
+static WORD_IRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tate"),
@@ -113470,12 +113470,12 @@ pub static WORD_IRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_IRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRE_CHILDREN),
+static WORD_IRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctory"),
         dictgen::InsensitiveStr::Ascii("elevant"),
@@ -113499,12 +113499,12 @@ pub static WORD_IRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_IRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRA_CHILDREN),
+static WORD_IRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nain"),
         dictgen::InsensitiveStr::Ascii("nains"),
@@ -113524,12 +113524,12 @@ pub static WORD_IRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_IP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IP_CHILDREN),
+static WORD_IP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IP_CHILDREN),
     value: None,
 };
 
-pub static WORD_IP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lementation"),
         dictgen::InsensitiveStr::Ascii("mrovement"),
@@ -113547,12 +113547,12 @@ pub static WORD_IP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_IO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IO_CHILDREN),
+static WORD_IO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clt"),
         dictgen::InsensitiveStr::Ascii("maped"),
@@ -113570,12 +113570,12 @@ pub static WORD_IO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_IN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IN_CHILDREN),
+static WORD_IN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IN_CHILDREN),
     value: None,
 };
 
-static WORD_IN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INA_NODE),
     Some(&WORD_INB_NODE),
     Some(&WORD_INC_NODE),
@@ -113604,12 +113604,12 @@ static WORD_IN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INV_CHILDREN),
+static WORD_INV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INV_CHILDREN),
     value: None,
 };
 
-static WORD_INV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INVA_NODE),
     None,
     None,
@@ -113638,12 +113638,12 @@ static WORD_INV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INVU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVU_CHILDREN),
+static WORD_INVU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lenrable"),
         dictgen::InsensitiveStr::Ascii("lernable"),
@@ -113673,12 +113673,12 @@ pub static WORD_INVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_INVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVO_CHILDREN),
+static WORD_INVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caition"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -113758,12 +113758,12 @@ pub static WORD_INVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVL_CHILDREN),
+static WORD_INVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aid"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -113787,12 +113787,12 @@ pub static WORD_INVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVI_CHILDREN),
+static WORD_INVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cation"),
@@ -113878,12 +113878,12 @@ pub static WORD_INVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INVE_CHILDREN),
+static WORD_INVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INVE_CHILDREN),
     value: None,
 };
 
-static WORD_INVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INVE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -113912,12 +113912,12 @@ static WORD_INVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INVET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVET_CHILDREN),
+static WORD_INVET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVET_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ory"),
@@ -113926,12 +113926,12 @@ pub static WORD_INVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_INVES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVES_CHILDREN),
+static WORD_INVES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVES_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itgate"),
         dictgen::InsensitiveStr::Ascii("itgated"),
@@ -114041,12 +114041,12 @@ pub static WORD_INVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_INVER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVER_CHILDREN),
+static WORD_INVER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVER_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("als"),
@@ -114088,12 +114088,12 @@ pub static WORD_INVER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_INVEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVEN_CHILDREN),
+static WORD_INVEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sions"),
         dictgen::InsensitiveStr::Ascii("tario"),
@@ -114123,12 +114123,12 @@ pub static WORD_INVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_INVEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVEI_CHILDREN),
+static WORD_INVEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tably"),
@@ -114137,12 +114137,12 @@ pub static WORD_INVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_INVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVA_CHILDREN),
+static WORD_INVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deras"),
         dictgen::InsensitiveStr::Ascii("derats"),
@@ -114232,12 +114232,12 @@ pub static WORD_INVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INU_CHILDREN),
+static WORD_INU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dstry"),
         dictgen::InsensitiveStr::Ascii("ition"),
@@ -114261,12 +114261,12 @@ pub static WORD_INU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_INT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INT_CHILDREN),
+static WORD_INT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INT_CHILDREN),
     value: None,
 };
 
-static WORD_INT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTA_NODE),
     None,
     None,
@@ -114295,12 +114295,12 @@ static WORD_INT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTU_CHILDREN),
+static WORD_INTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("atively"),
@@ -114338,12 +114338,12 @@ pub static WORD_INTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_INTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTT_CHILDREN),
+static WORD_INTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("errupt"),
         dictgen::InsensitiveStr::Ascii("erupt"),
@@ -114361,12 +114361,12 @@ pub static WORD_INTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_INTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTS_CHILDREN),
+static WORD_INTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("alled"),
@@ -114406,12 +114406,12 @@ pub static WORD_INTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_INTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTR_CHILDREN),
+static WORD_INTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTR_CHILDREN),
     value: None,
 };
 
-static WORD_INTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTRA_NODE),
     None,
     Some(&WORD_INTRC_NODE),
@@ -114440,12 +114440,12 @@ static WORD_INTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRU_CHILDREN),
+static WORD_INTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -114485,12 +114485,12 @@ pub static WORD_INTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INTRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRR_CHILDREN),
+static WORD_INTRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("upt"),
         dictgen::InsensitiveStr::Ascii("upted"),
@@ -114506,12 +114506,12 @@ pub static WORD_INTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_INTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRO_CHILDREN),
+static WORD_INTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("decks"),
         dictgen::InsensitiveStr::Ascii("diced"),
@@ -114607,12 +114607,12 @@ pub static WORD_INTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_INTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRI_CHILDREN),
+static WORD_INTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caces"),
         dictgen::InsensitiveStr::Ascii("casies"),
@@ -114678,12 +114678,12 @@ pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRE_CHILDREN),
+static WORD_INTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cacies"),
         dictgen::InsensitiveStr::Ascii("eg"),
@@ -114751,34 +114751,34 @@ pub static WORD_INTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_INTRD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRD_CHILDREN),
+static WORD_INTRD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uced")],
     values: &[&["introduced"]],
     range: 4..=4,
 };
 
-static WORD_INTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRC_CHILDREN),
+static WORD_INTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utions")],
     values: &[&["instructions"]],
     range: 6..=6,
 };
 
-static WORD_INTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRA_CHILDREN),
+static WORD_INTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cacies"),
         dictgen::InsensitiveStr::Ascii("cicies"),
@@ -114802,12 +114802,12 @@ pub static WORD_INTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_INTQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTQ_CHILDREN),
+static WORD_INTQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uire"),
         dictgen::InsensitiveStr::Ascii("uired"),
@@ -114825,12 +114825,12 @@ pub static WORD_INTQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INTP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTP_CHILDREN),
+static WORD_INTP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("reter"),
         dictgen::InsensitiveStr::Ascii("ut"),
@@ -114840,12 +114840,12 @@ pub static WORD_INTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTO_CHILDREN),
+static WORD_INTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("larant"),
         dictgen::InsensitiveStr::Ascii("lerace"),
@@ -114913,12 +114913,12 @@ pub static WORD_INTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_INTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTI_CHILDREN),
+static WORD_INTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTI_CHILDREN),
     value: None,
 };
 
-static WORD_INTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTIA_NODE),
     None,
     Some(&WORD_INTIC_NODE),
@@ -114947,12 +114947,12 @@ static WORD_INTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIU_CHILDREN),
+static WORD_INTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tive"),
@@ -114962,12 +114962,12 @@ pub static WORD_INTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIT_CHILDREN),
+static WORD_INTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -114989,34 +114989,34 @@ pub static WORD_INTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIR_CHILDREN),
+static WORD_INTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cate")],
     values: &[&["intricate"]],
     range: 4..=4,
 };
 
-static WORD_INTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIN_CHILDREN),
+static WORD_INTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ite")],
     values: &[&["infinite"]],
     range: 3..=3,
 };
 
-static WORD_INTIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIM_CHILDREN),
+static WORD_INTIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adate"),
         dictgen::InsensitiveStr::Ascii("adated"),
@@ -115082,12 +115082,12 @@ pub static WORD_INTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INTIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIL_CHILDREN),
+static WORD_INTIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ising"),
         dictgen::InsensitiveStr::Ascii("ize"),
@@ -115107,12 +115107,12 @@ pub static WORD_INTIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INTII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTII_CHILDREN),
+static WORD_INTII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTII_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alise"),
@@ -115128,23 +115128,23 @@ pub static WORD_INTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INTIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIG_CHILDREN),
+static WORD_INTIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["integer"]],
     range: 2..=2,
 };
 
-static WORD_INTID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTID_CHILDREN),
+static WORD_INTID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTID_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imate"),
         dictgen::InsensitiveStr::Ascii("imation"),
@@ -115153,12 +115153,12 @@ pub static WORD_INTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIC_CHILDREN),
+static WORD_INTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("racies"),
@@ -115168,12 +115168,12 @@ pub static WORD_INTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIA_CHILDREN),
+static WORD_INTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilise"),
         dictgen::InsensitiveStr::Ascii("ilised"),
@@ -115293,12 +115293,12 @@ pub static WORD_INTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INTG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTG_CHILDREN),
+static WORD_INTG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -115308,12 +115308,12 @@ pub static WORD_INTG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_INTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTE_CHILDREN),
+static WORD_INTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTE_CHILDREN),
     value: None,
 };
 
-static WORD_INTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTEA_NODE),
     None,
     Some(&WORD_INTEC_NODE),
@@ -115342,12 +115342,12 @@ static WORD_INTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEV_CHILDREN),
+static WORD_INTEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("als"),
@@ -115363,12 +115363,12 @@ pub static WORD_INTEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_INTES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTES_CHILDREN),
+static WORD_INTES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTES_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ection"),
         dictgen::InsensitiveStr::Ascii("ections"),
@@ -115400,12 +115400,12 @@ pub static WORD_INTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INTER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTER_CHILDREN),
+static WORD_INTER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTER_CHILDREN),
     value: None,
 };
 
-static WORD_INTER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTERA_NODE),
     Some(&WORD_INTERB_NODE),
     Some(&WORD_INTERC_NODE),
@@ -115434,12 +115434,12 @@ static WORD_INTER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERW_CHILDREN),
+static WORD_INTERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebbs"),
         dictgen::InsensitiveStr::Ascii("ebers"),
@@ -115449,12 +115449,12 @@ pub static WORD_INTERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_INTERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERV_CHILDREN),
+static WORD_INTERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("alles"),
@@ -115542,12 +115542,12 @@ pub static WORD_INTERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_INTERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERU_CHILDREN),
+static WORD_INTERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("ptable"),
@@ -115571,12 +115571,12 @@ pub static WORD_INTERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_INTERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERT_CHILDREN),
+static WORD_INTERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ained"),
         dictgen::InsensitiveStr::Ascii("aining"),
@@ -115604,12 +115604,12 @@ pub static WORD_INTERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_INTERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERS_CHILDREN),
+static WORD_INTERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cetion"),
         dictgen::InsensitiveStr::Ascii("eccion"),
@@ -115697,12 +115697,12 @@ pub static WORD_INTERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_INTERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERR_CHILDREN),
+static WORD_INTERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("accial"),
         dictgen::InsensitiveStr::Ascii("act"),
@@ -115800,12 +115800,12 @@ pub static WORD_INTERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_INTERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTERP_CHILDREN),
+static WORD_INTERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTERP_CHILDREN),
     value: None,
 };
 
-static WORD_INTERP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTERP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -115834,12 +115834,12 @@ static WORD_INTERP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTERPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERPR_CHILDREN),
+static WORD_INTERPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atation"),
         dictgen::InsensitiveStr::Ascii("atations"),
@@ -115935,12 +115935,12 @@ pub static WORD_INTERPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=9,
 };
 
-static WORD_INTERPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERPO_CHILDREN),
+static WORD_INTERPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laed"),
         dictgen::InsensitiveStr::Ascii("laion"),
@@ -115982,12 +115982,12 @@ pub static WORD_INTERPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=8,
 };
 
-static WORD_INTERPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERPL_CHILDREN),
+static WORD_INTERPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("oate"),
@@ -116009,12 +116009,12 @@ pub static WORD_INTERPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_INTERPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERPE_CHILDREN),
+static WORD_INTERPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rated"),
         dictgen::InsensitiveStr::Ascii("reters"),
@@ -116062,12 +116062,12 @@ pub static WORD_INTERPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_INTERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERO_CHILDREN),
+static WORD_INTERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gate"),
         dictgen::InsensitiveStr::Ascii("gation"),
@@ -116089,12 +116089,12 @@ pub static WORD_INTERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=9,
 };
 
-static WORD_INTERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERN_CHILDREN),
+static WORD_INTERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acional"),
         dictgen::InsensitiveStr::Ascii("all"),
@@ -116186,12 +116186,12 @@ pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_INTERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERM_CHILDREN),
+static WORD_INTERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERM_CHILDREN),
     value: Some(&["interim", "intern"]),
 };
 
-pub static WORD_INTERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edate"),
         dictgen::InsensitiveStr::Ascii("ediare"),
@@ -116235,12 +116235,12 @@ pub static WORD_INTERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_INTERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERL_CHILDREN),
+static WORD_INTERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("eaed"),
@@ -116266,12 +116266,12 @@ pub static WORD_INTERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_INTERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERI_CHILDREN),
+static WORD_INTERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oara"),
         dictgen::InsensitiveStr::Ascii("oare"),
@@ -116297,12 +116297,12 @@ pub static WORD_INTERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_INTERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERG_CHILDREN),
+static WORD_INTERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -116342,12 +116342,12 @@ pub static WORD_INTERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_INTERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERF_CHILDREN),
+static WORD_INTERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acce"),
         dictgen::InsensitiveStr::Ascii("act"),
@@ -116425,12 +116425,12 @@ pub static WORD_INTERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_INTERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTERE_CHILDREN),
+static WORD_INTERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTERE_CHILDREN),
     value: None,
 };
 
-static WORD_INTERE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTERE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTEREA_NODE),
     None,
     Some(&WORD_INTEREC_NODE),
@@ -116459,34 +116459,34 @@ static WORD_INTERE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTEREW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREW_CHILDREN),
+static WORD_INTEREW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREW_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bs")],
     values: &[&["interwebs"]],
     range: 2..=2,
 };
 
-static WORD_INTEREV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREV_CHILDREN),
+static WORD_INTEREV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iew")],
     values: &[&["interview"]],
     range: 3..=3,
 };
 
-static WORD_INTERET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERET_CHILDREN),
+static WORD_INTERET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERET_CHILDREN),
     value: Some(&["interest"]),
 };
 
-pub static WORD_INTERET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("sed"),
@@ -116495,12 +116495,12 @@ pub static WORD_INTERET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=3,
 };
 
-static WORD_INTERES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERES_CHILDREN),
+static WORD_INTERES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERES_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -116570,12 +116570,12 @@ pub static WORD_INTERES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_INTERER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERER_CHILDREN),
+static WORD_INTERER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERER_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sted"),
         dictgen::InsensitiveStr::Ascii("sting"),
@@ -116584,12 +116584,12 @@ pub static WORD_INTERER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=5,
 };
 
-static WORD_INTEREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREP_CHILDREN),
+static WORD_INTEREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREP_CHILDREN),
     value: Some(&["interop"]),
 };
 
-pub static WORD_INTEREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eted"),
         dictgen::InsensitiveStr::Ascii("olate"),
@@ -116623,12 +116623,12 @@ pub static WORD_INTEREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_INTEREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREN_CHILDREN),
+static WORD_INTEREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -116637,12 +116637,12 @@ pub static WORD_INTEREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=2,
 };
 
-static WORD_INTEREL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREL_CHILDREN),
+static WORD_INTEREL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("aved"),
@@ -116651,12 +116651,12 @@ pub static WORD_INTEREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=4,
 };
 
-static WORD_INTEREF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREF_CHILDREN),
+static WORD_INTEREF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erence"),
         dictgen::InsensitiveStr::Ascii("erences"),
@@ -116666,34 +116666,34 @@ pub static WORD_INTEREF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=7,
 };
 
-static WORD_INTEREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREE_CHILDREN),
+static WORD_INTEREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sted")],
     values: &[&["interested"]],
     range: 4..=4,
 };
 
-static WORD_INTERED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERED_CHILDREN),
+static WORD_INTERED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERED_CHILDREN),
     value: Some(&["interred", "interned"]),
 };
 
-pub static WORD_INTERED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_INTEREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREC_CHILDREN),
+static WORD_INTEREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ptor"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -116717,12 +116717,12 @@ pub static WORD_INTEREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_INTEREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREA_CHILDREN),
+static WORD_INTEREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -116738,12 +116738,12 @@ pub static WORD_INTEREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_INTERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERD_CHILDREN),
+static WORD_INTERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ependant"),
         dictgen::InsensitiveStr::Ascii("ependecies"),
@@ -116752,12 +116752,12 @@ pub static WORD_INTERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 8..=10,
 };
 
-static WORD_INTERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERC_CHILDREN),
+static WORD_INTERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahnge"),
         dictgen::InsensitiveStr::Ascii("ahnged"),
@@ -116819,23 +116819,23 @@ pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_INTERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERB_CHILDREN),
+static WORD_INTERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("read")],
     values: &[&["interbreed", "interbred"]],
     range: 4..=4,
 };
 
-static WORD_INTERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERA_CHILDREN),
+static WORD_INTERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -116969,12 +116969,12 @@ pub static WORD_INTERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_INTEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEP_CHILDREN),
+static WORD_INTEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("olate"),
         dictgen::InsensitiveStr::Ascii("olated"),
@@ -117016,12 +117016,12 @@ pub static WORD_INTEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INTEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEN_CHILDREN),
+static WORD_INTEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -117101,23 +117101,23 @@ pub static WORD_INTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_INTEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEM_CHILDREN),
+static WORD_INTEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ediary")],
     values: &[&["intermediary"]],
     range: 6..=6,
 };
 
-static WORD_INTEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEL_CHILDREN),
+static WORD_INTEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eaved"),
         dictgen::InsensitiveStr::Ascii("ectual"),
@@ -117203,12 +117203,12 @@ pub static WORD_INTEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_INTEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEG_CHILDREN),
+static WORD_INTEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arte"),
         dictgen::InsensitiveStr::Ascii("arted"),
@@ -117276,12 +117276,12 @@ pub static WORD_INTEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INTEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEF_CHILDREN),
+static WORD_INTEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -117305,23 +117305,23 @@ pub static WORD_INTEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_INTEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEE_CHILDREN),
+static WORD_INTEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gration")],
     values: &[&["integration"]],
     range: 7..=7,
 };
 
-static WORD_INTED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTED_CHILDREN),
+static WORD_INTED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTED_CHILDREN),
     value: Some(&["inetd", "intend"]),
 };
 
-pub static WORD_INTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -117330,12 +117330,12 @@ pub static WORD_INTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_INTEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEC_CHILDREN),
+static WORD_INTEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("epted"),
         dictgen::InsensitiveStr::Ascii("epting"),
@@ -117344,12 +117344,12 @@ pub static WORD_INTEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_INTEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEA_CHILDREN),
+static WORD_INTEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -117358,23 +117358,23 @@ pub static WORD_INTEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_INTD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTD_CHILDREN),
+static WORD_INTD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icating")],
     values: &[&["indicating"]],
     range: 7..=7,
 };
 
-static WORD_INTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTA_CHILDREN),
+static WORD_INTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ces"),
         dictgen::InsensitiveStr::Ascii("ck"),
@@ -117438,12 +117438,12 @@ pub static WORD_INTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_INS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INS_CHILDREN),
+static WORD_INS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INS_CHILDREN),
     value: None,
 };
 
-static WORD_INS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSA_NODE),
     None,
     Some(&WORD_INSC_NODE),
@@ -117472,12 +117472,12 @@ static WORD_INS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSU_CHILDREN),
+static WORD_INSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alted"),
         dictgen::InsensitiveStr::Ascii("bstantiated"),
@@ -117553,12 +117553,12 @@ pub static WORD_INSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_INST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INST_CHILDREN),
+static WORD_INST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INST_CHILDREN),
     value: None,
 };
 
-static WORD_INST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSTA_NODE),
     None,
     None,
@@ -117587,12 +117587,12 @@ static WORD_INST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTU_CHILDREN),
+static WORD_INSTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -117648,12 +117648,12 @@ pub static WORD_INSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_INSTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTT_CHILDREN),
+static WORD_INSTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ruction"),
         dictgen::InsensitiveStr::Ascii("uction"),
@@ -117662,12 +117662,12 @@ pub static WORD_INSTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_INSTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTS_CHILDREN),
+static WORD_INSTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("allation"),
@@ -117685,12 +117685,12 @@ pub static WORD_INSTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INSTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INSTR_CHILDREN),
+static WORD_INSTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INSTR_CHILDREN),
     value: None,
 };
 
-static WORD_INSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INSTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSTRA_NODE),
     None,
     Some(&WORD_INSTRC_NODE),
@@ -117719,12 +117719,12 @@ static WORD_INSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRU_CHILDREN),
+static WORD_INSTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("ccional"),
@@ -117820,23 +117820,23 @@ pub static WORD_INSTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=10,
 };
 
-static WORD_INSTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRO_CHILDREN),
+static WORD_INSTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("spection")],
     values: &[&["introspection"]],
     range: 8..=8,
 };
 
-static WORD_INSTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRI_CHILDREN),
+static WORD_INSTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("nics"),
@@ -117852,23 +117852,23 @@ pub static WORD_INSTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_INSTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRE_CHILDREN),
+static WORD_INSTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ad")],
     values: &[&["instead"]],
     range: 2..=2,
 };
 
-static WORD_INSTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRC_CHILDREN),
+static WORD_INSTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tional"),
@@ -117900,12 +117900,12 @@ pub static WORD_INSTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_INSTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRA_CHILDREN),
+static WORD_INSTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -117929,12 +117929,12 @@ pub static WORD_INSTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_INSTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTN_CHILDREN),
+static WORD_INSTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -117972,12 +117972,12 @@ pub static WORD_INSTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_INSTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTL_CHILDREN),
+static WORD_INSTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alation"),
@@ -118013,12 +118013,12 @@ pub static WORD_INSTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_INSTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTI_CHILDREN),
+static WORD_INSTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atiate"),
         dictgen::InsensitiveStr::Ascii("cnt"),
@@ -118086,12 +118086,12 @@ pub static WORD_INSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_INSTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTE_CHILDREN),
+static WORD_INSTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("add"),
         dictgen::InsensitiveStr::Ascii("ading"),
@@ -118145,12 +118145,12 @@ pub static WORD_INSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_INSTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INSTA_CHILDREN),
+static WORD_INSTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INSTA_CHILDREN),
     value: None,
 };
 
-static WORD_INSTA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INSTA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSTAA_NODE),
     Some(&WORD_INSTAB_NODE),
     Some(&WORD_INSTAC_NODE),
@@ -118179,12 +118179,12 @@ static WORD_INSTA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSTAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAT_CHILDREN),
+static WORD_INSTAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -118206,23 +118206,23 @@ pub static WORD_INSTAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_INSTAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAS_CHILDREN),
+static WORD_INSTAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lled")],
     values: &[&["installed"]],
     range: 4..=4,
 };
 
-static WORD_INSTAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAN_CHILDREN),
+static WORD_INSTAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atiation"),
         dictgen::InsensitiveStr::Ascii("cce"),
@@ -118316,12 +118316,12 @@ pub static WORD_INSTAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_INSTAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAL_CHILDREN),
+static WORD_INSTAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("altion"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -118397,12 +118397,12 @@ pub static WORD_INSTAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_INSTAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAE_CHILDREN),
+static WORD_INSTAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -118411,23 +118411,23 @@ pub static WORD_INSTAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_INSTAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAD_CHILDREN),
+static WORD_INSTAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAD_CHILDREN),
     value: Some(&["instead"]),
 };
 
-pub static WORD_INSTAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["instead"]],
     range: 1..=1,
 };
 
-static WORD_INSTAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAC_CHILDREN),
+static WORD_INSTAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -118437,12 +118437,12 @@ pub static WORD_INSTAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_INSTAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAB_CHILDREN),
+static WORD_INSTAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("iliy"),
@@ -118460,23 +118460,23 @@ pub static WORD_INSTAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_INSTAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAA_CHILDREN),
+static WORD_INSTAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nce")],
     values: &[&["instance"]],
     range: 3..=3,
 };
 
-static WORD_INSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSR_CHILDREN),
+static WORD_INSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uction"),
         dictgen::InsensitiveStr::Ascii("ugency"),
@@ -118485,12 +118485,12 @@ pub static WORD_INSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_INSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSP_CHILDREN),
+static WORD_INSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("eccion"),
@@ -118548,12 +118548,12 @@ pub static WORD_INSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_INSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSO_CHILDREN),
+static WORD_INSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mina"),
         dictgen::InsensitiveStr::Ascii("nmia"),
@@ -118563,23 +118563,23 @@ pub static WORD_INSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_INSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSM_CHILDREN),
+static WORD_INSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onia")],
     values: &[&["insomnia"]],
     range: 4..=4,
 };
 
-static WORD_INSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSL_CHILDREN),
+static WORD_INSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uated"),
         dictgen::InsensitiveStr::Ascii("uts"),
@@ -118588,12 +118588,12 @@ pub static WORD_INSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_INSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSI_CHILDREN),
+static WORD_INSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dde"),
@@ -118675,12 +118675,12 @@ pub static WORD_INSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INSE_CHILDREN),
+static WORD_INSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INSE_CHILDREN),
     value: None,
 };
 
-static WORD_INSE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INSE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSEA_NODE),
     None,
     Some(&WORD_INSEC_NODE),
@@ -118709,12 +118709,12 @@ static WORD_INSE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSET_CHILDREN),
+static WORD_INSET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSET_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("ead"),
@@ -118732,12 +118732,12 @@ pub static WORD_INSET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_INSES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSES_CHILDREN),
+static WORD_INSES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSES_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itive"),
         dictgen::InsensitiveStr::Ascii("itively"),
@@ -118753,12 +118753,12 @@ pub static WORD_INSES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_INSER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSER_CHILDREN),
+static WORD_INSER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSER_CHILDREN),
     value: Some(&["insert"]),
 };
 
-pub static WORD_INSER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -118802,12 +118802,12 @@ pub static WORD_INSER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_INSEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSEP_CHILDREN),
+static WORD_INSEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -118837,12 +118837,12 @@ pub static WORD_INSEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_INSEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSEN_CHILDREN),
+static WORD_INSEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itive"),
         dictgen::InsensitiveStr::Ascii("itively"),
@@ -118890,12 +118890,12 @@ pub static WORD_INSEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_INSEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSEC_CHILDREN),
+static WORD_INSEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tes"),
         dictgen::InsensitiveStr::Ascii("tiverous"),
@@ -118915,23 +118915,23 @@ pub static WORD_INSEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INSEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSEA_CHILDREN),
+static WORD_INSEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["instead"]],
     range: 1..=1,
 };
 
-static WORD_INSD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSD_CHILDREN),
+static WORD_INSD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ie"),
@@ -118940,12 +118940,12 @@ pub static WORD_INSD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_INSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSC_CHILDREN),
+static WORD_INSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ets"),
         dictgen::InsensitiveStr::Ascii("peting"),
@@ -118965,12 +118965,12 @@ pub static WORD_INSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSA_CHILDREN),
+static WORD_INSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ll"),
         dictgen::InsensitiveStr::Ascii("llation"),
@@ -119000,12 +119000,12 @@ pub static WORD_INSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_INR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INR_CHILDREN),
+static WORD_INR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aged"),
         dictgen::InsensitiveStr::Ascii("ement"),
@@ -119037,12 +119037,12 @@ pub static WORD_INR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_INQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INQ_CHILDREN),
+static WORD_INQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uier"),
         dictgen::InsensitiveStr::Ascii("uirey"),
@@ -119098,12 +119098,12 @@ pub static WORD_INQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_INP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INP_CHILDREN),
+static WORD_INP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -119235,12 +119235,12 @@ pub static WORD_INP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_INO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INO_CHILDREN),
+static WORD_INO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("btrusive"),
         dictgen::InsensitiveStr::Ascii("cence"),
@@ -119280,12 +119280,12 @@ pub static WORD_INO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_INN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INN_CHILDREN),
+static WORD_INN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("accible"),
         dictgen::InsensitiveStr::Ascii("active"),
@@ -119371,12 +119371,12 @@ pub static WORD_INN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_INM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INM_CHILDREN),
+static WORD_INM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ediate"),
         dictgen::InsensitiveStr::Ascii("ediatelly"),
@@ -119406,12 +119406,12 @@ pub static WORD_INM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_INL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INL_CHILDREN),
+static WORD_INL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alid"),
         dictgen::InsensitiveStr::Ascii("cine"),
@@ -119465,12 +119465,12 @@ pub static WORD_INL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_INK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INK_CHILDREN),
+static WORD_INK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INK_CHILDREN),
     value: None,
 };
 
-pub static WORD_INK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ompatible"),
         dictgen::InsensitiveStr::Ascii("ompetence"),
@@ -119480,12 +119480,12 @@ pub static WORD_INK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=9,
 };
 
-static WORD_INJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INJ_CHILDREN),
+static WORD_INJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cetion"),
         dictgen::InsensitiveStr::Ascii("est"),
@@ -119505,12 +119505,12 @@ pub static WORD_INJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_INI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INI_CHILDREN),
+static WORD_INI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INI_CHILDREN),
     value: None,
 };
 
-static WORD_INI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INIA_NODE),
     None,
     None,
@@ -119539,12 +119539,12 @@ static WORD_INI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_INIZ_NODE),
 ];
 
-static WORD_INIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIZ_CHILDREN),
+static WORD_INIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialize"),
         dictgen::InsensitiveStr::Ascii("ialized"),
@@ -119554,23 +119554,23 @@ pub static WORD_INIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_INIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIV_CHILDREN),
+static WORD_INIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("isible")],
     values: &[&["invisible"]],
     range: 6..=6,
 };
 
-static WORD_INIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INIT_CHILDREN),
+static WORD_INIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INIT_CHILDREN),
     value: None,
 };
 
-static WORD_INIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INIT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INITA_NODE),
     None,
     None,
@@ -119599,12 +119599,12 @@ static WORD_INIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INITU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITU_CHILDREN),
+static WORD_INITU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialisation"),
         dictgen::InsensitiveStr::Ascii("ialization"),
@@ -119614,12 +119614,12 @@ pub static WORD_INITU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_INITM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITM_CHILDREN),
+static WORD_INITM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acy"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -119635,12 +119635,12 @@ pub static WORD_INITM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_INITL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITL_CHILDREN),
+static WORD_INITL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iasation"),
         dictgen::InsensitiveStr::Ascii("iase"),
@@ -119664,12 +119664,12 @@ pub static WORD_INITL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_INITI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INITI_CHILDREN),
+static WORD_INITI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INITI_CHILDREN),
     value: None,
 };
 
-static WORD_INITI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INITI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INITIA_NODE),
     None,
     None,
@@ -119698,12 +119698,12 @@ static WORD_INITI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INITIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIT_CHILDREN),
+static WORD_INITIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aive"),
         dictgen::InsensitiveStr::Ascii("alisation"),
@@ -119745,23 +119745,23 @@ pub static WORD_INITIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=11,
 };
 
-static WORD_INITIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIS_CHILDREN),
+static WORD_INITIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["initials"]],
     range: 1..=1,
 };
 
-static WORD_INITIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIL_CHILDREN),
+static WORD_INITIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aize"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -119831,12 +119831,12 @@ pub static WORD_INITIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=11,
 };
 
-static WORD_INITII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITII_CHILDREN),
+static WORD_INITII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITII_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alise"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -119845,12 +119845,12 @@ pub static WORD_INITII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=5,
 };
 
-static WORD_INITIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INITIA_CHILDREN),
+static WORD_INITIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INITIA_CHILDREN),
     value: None,
 };
 
-static WORD_INITIA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INITIA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -119879,23 +119879,23 @@ static WORD_INITIA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INITIAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIAV_CHILDREN),
+static WORD_INITIAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ite")],
     values: &[&["initiatives"]],
     range: 3..=3,
 };
 
-static WORD_INITIAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIAT_CHILDREN),
+static WORD_INITIAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -119931,12 +119931,12 @@ pub static WORD_INITIAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_INITIAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INITIAL_CHILDREN),
+static WORD_INITIAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INITIAL_CHILDREN),
     value: None,
 };
 
-static WORD_INITIAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INITIAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -119965,12 +119965,12 @@ static WORD_INITIAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_INITIALZ_NODE),
 ];
 
-static WORD_INITIALZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALZ_CHILDREN),
+static WORD_INITIALZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIALZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -119996,12 +119996,12 @@ pub static WORD_INITIALZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=5,
 };
 
-static WORD_INITIALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALY_CHILDREN),
+static WORD_INITIALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALY_CHILDREN),
     value: Some(&["initially"]),
 };
 
-pub static WORD_INITIALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -120027,12 +120027,12 @@ pub static WORD_INITIALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=4,
 };
 
-static WORD_INITIALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALS_CHILDREN),
+static WORD_INITIALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -120050,23 +120050,23 @@ pub static WORD_INITIALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=5,
 };
 
-static WORD_INITIALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALL_CHILDREN),
+static WORD_INITIALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALL_CHILDREN),
     value: Some(&["initial", "initially"]),
 };
 
-pub static WORD_INITIALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["initially"]],
     range: 2..=2,
 };
 
-static WORD_INITIALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALI_CHILDREN),
+static WORD_INITIALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alise"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -120186,23 +120186,23 @@ pub static WORD_INITIALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=7,
 };
 
-static WORD_INITIALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALE_CHILDREN),
+static WORD_INITIALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALE_CHILDREN),
     value: Some(&["initial"]),
 };
 
-pub static WORD_INITIALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["initials", "initialise", "initializes", "initialises"]],
     range: 1..=1,
 };
 
-static WORD_INITIAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIAI_CHILDREN),
+static WORD_INITIAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lization"),
         dictgen::InsensitiveStr::Ascii("lize"),
@@ -120228,12 +120228,12 @@ pub static WORD_INITIAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=8,
 };
 
-static WORD_INITA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INITA_CHILDREN),
+static WORD_INITA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INITA_CHILDREN),
     value: None,
 };
 
-static WORD_INITA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INITA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -120262,12 +120262,12 @@ static WORD_INITA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INITAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITAT_CHILDREN),
+static WORD_INITAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -120295,12 +120295,12 @@ pub static WORD_INITAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_INITAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITAL_CHILDREN),
+static WORD_INITAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITAL_CHILDREN),
     value: Some(&["initial"]),
 };
 
-pub static WORD_INITAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -120366,12 +120366,12 @@ pub static WORD_INITAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_INITAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITAI_CHILDREN),
+static WORD_INITAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lisation"),
@@ -120437,12 +120437,12 @@ pub static WORD_INITAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_INIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIS_CHILDREN),
+static WORD_INIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghts"),
         dictgen::InsensitiveStr::Ascii("ialise"),
@@ -120462,12 +120462,12 @@ pub static WORD_INIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ININ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ININ_CHILDREN),
+static WORD_ININ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ININ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ININ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ININ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ite"),
         dictgen::InsensitiveStr::Ascii("telligent"),
@@ -120489,23 +120489,23 @@ pub static WORD_ININ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_INIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIL_CHILDREN),
+static WORD_INIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ne")],
     values: &[&["inline"]],
     range: 2..=2,
 };
 
-static WORD_INII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INII_CHILDREN),
+static WORD_INII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INII_CHILDREN),
     value: None,
 };
 
-pub static WORD_INII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("talize"),
         dictgen::InsensitiveStr::Ascii("talized"),
@@ -120531,12 +120531,12 @@ pub static WORD_INII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_INIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIF_CHILDREN),
+static WORD_INIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inite"),
         dictgen::InsensitiveStr::Ascii("inity"),
@@ -120558,12 +120558,12 @@ pub static WORD_INIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_INIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIE_CHILDREN),
+static WORD_INIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -120581,12 +120581,12 @@ pub static WORD_INIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INID_CHILDREN),
+static WORD_INID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INID_CHILDREN),
     value: None,
 };
 
-pub static WORD_INID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ans"),
         dictgen::InsensitiveStr::Ascii("cates"),
@@ -120616,12 +120616,12 @@ pub static WORD_INID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_INIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIA_CHILDREN),
+static WORD_INIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lization"),
         dictgen::InsensitiveStr::Ascii("lize"),
@@ -120641,12 +120641,12 @@ pub static WORD_INIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INH_CHILDREN),
+static WORD_INH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INH_CHILDREN),
     value: Some(&["in"]),
 };
 
-pub static WORD_INH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abitans"),
         dictgen::InsensitiveStr::Ascii("abitat"),
@@ -120756,12 +120756,12 @@ pub static WORD_INH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_ING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ING_CHILDREN),
+static WORD_ING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ING_CHILDREN),
     value: None,
 };
 
-pub static WORD_ING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eger"),
         dictgen::InsensitiveStr::Ascii("egral"),
@@ -120835,12 +120835,12 @@ pub static WORD_ING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_INF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INF_CHILDREN),
+static WORD_INF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INF_CHILDREN),
     value: None,
 };
 
-static WORD_INF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INFA_NODE),
     None,
     None,
@@ -120869,12 +120869,12 @@ static WORD_INF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFU_CHILDREN),
+static WORD_INFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lenced"),
         dictgen::InsensitiveStr::Ascii("lences"),
@@ -120884,12 +120884,12 @@ pub static WORD_INFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_INFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFR_CHILDREN),
+static WORD_INFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antryman"),
         dictgen::InsensitiveStr::Ascii("aread"),
@@ -120981,12 +120981,12 @@ pub static WORD_INFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_INFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFO_CHILDREN),
+static WORD_INFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emation"),
         dictgen::InsensitiveStr::Ascii("grahic"),
@@ -121120,12 +121120,12 @@ pub static WORD_INFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFL_CHILDREN),
+static WORD_INFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amable"),
         dictgen::InsensitiveStr::Ascii("amation"),
@@ -121213,12 +121213,12 @@ pub static WORD_INFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_INFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFI_CHILDREN),
+static WORD_INFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deltiy"),
         dictgen::InsensitiveStr::Ascii("dility"),
@@ -121310,12 +121310,12 @@ pub static WORD_INFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFE_CHILDREN),
+static WORD_INFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccious"),
         dictgen::InsensitiveStr::Ascii("ctation"),
@@ -121377,12 +121377,12 @@ pub static WORD_INFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_INFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFA_CHILDREN),
+static WORD_INFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("illible"),
         dictgen::InsensitiveStr::Ascii("lability"),
@@ -121422,12 +121422,12 @@ pub static WORD_INFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INE_CHILDREN),
+static WORD_INE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INE_CHILDREN),
     value: Some(&["one"]),
 };
 
-static WORD_INE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INEA_NODE),
     None,
     None,
@@ -121456,12 +121456,12 @@ static WORD_INE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEX_CHILDREN),
+static WORD_INEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEX_CHILDREN),
     value: Some(&["index"]),
 };
 
-pub static WORD_INEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blicably"),
         dictgen::InsensitiveStr::Ascii("eprienced"),
@@ -121531,12 +121531,12 @@ pub static WORD_INEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_INEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEV_CHILDREN),
+static WORD_INEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atible"),
         dictgen::InsensitiveStr::Ascii("etable"),
@@ -121578,23 +121578,23 @@ pub static WORD_INEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_INET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INET_CHILDREN),
+static WORD_INET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INET_CHILDREN),
     value: None,
 };
 
-pub static WORD_INET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rrupts")],
     values: &[&["interrupts"]],
     range: 6..=6,
 };
 
-static WORD_INES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INES_CHILDREN),
+static WORD_INES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INES_CHILDREN),
     value: Some(&["lines"]),
 };
 
-pub static WORD_INES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rted"),
         dictgen::InsensitiveStr::Ascii("tart"),
@@ -121603,12 +121603,12 @@ pub static WORD_INES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_INER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INER_CHILDREN),
+static WORD_INER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INER_CHILDREN),
     value: None,
 };
 
-pub static WORD_INER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("face"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -121652,12 +121652,12 @@ pub static WORD_INER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEQ_CHILDREN),
+static WORD_INEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ality"),
         dictgen::InsensitiveStr::Ascii("aulity"),
@@ -121675,45 +121675,45 @@ pub static WORD_INEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEN_CHILDREN),
+static WORD_INEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tory")],
     values: &[&["inventory"]],
     range: 4..=4,
 };
 
-static WORD_INEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEL_CHILDREN),
+static WORD_INEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ligible")],
     values: &[&["ineligible"]],
     range: 7..=7,
 };
 
-static WORD_INEJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEJ_CHILDREN),
+static WORD_INEJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ction")],
     values: &[&["injection"]],
     range: 5..=5,
 };
 
-static WORD_INEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEG_CHILDREN),
+static WORD_INEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rate"),
         dictgen::InsensitiveStr::Ascii("rated"),
@@ -121722,12 +121722,12 @@ pub static WORD_INEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_INEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEF_CHILDREN),
+static WORD_INEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fciency"),
         dictgen::InsensitiveStr::Ascii("fcient"),
@@ -121775,23 +121775,23 @@ pub static WORD_INEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_INEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEA_CHILDREN),
+static WORD_INEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("risation")],
     values: &[&["linearisation"]],
     range: 8..=8,
 };
 
-static WORD_IND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IND_CHILDREN),
+static WORD_IND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IND_CHILDREN),
     value: None,
 };
 
-static WORD_IND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IND_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INDA_NODE),
     None,
     Some(&WORD_INDC_NODE),
@@ -121820,23 +121820,23 @@ static WORD_IND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INDX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDX_CHILDREN),
+static WORD_INDX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDX_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["indexes"]],
     range: 2..=2,
 };
 
-static WORD_INDV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDV_CHILDREN),
+static WORD_INDV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idual"),
         dictgen::InsensitiveStr::Ascii("iduals"),
@@ -121845,12 +121845,12 @@ pub static WORD_INDV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_INDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDU_CHILDREN),
+static WORD_INDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gle"),
         dictgen::InsensitiveStr::Ascii("lgue"),
@@ -121904,23 +121904,23 @@ pub static WORD_INDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_INDS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDS_CHILDREN),
+static WORD_INDS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utry")],
     values: &[&["industry"]],
     range: 4..=4,
 };
 
-static WORD_INDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDR_CHILDREN),
+static WORD_INDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("oduction"),
@@ -121930,12 +121930,12 @@ pub static WORD_INDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_INDP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDP_CHILDREN),
+static WORD_INDP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("endence"),
         dictgen::InsensitiveStr::Ascii("endent"),
@@ -121945,12 +121945,12 @@ pub static WORD_INDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_INDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDO_CHILDREN),
+static WORD_INDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crtinated"),
         dictgen::InsensitiveStr::Ascii("crtination"),
@@ -121998,12 +121998,12 @@ pub static WORD_INDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_INDL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDL_CHILDREN),
+static WORD_INDL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uces"),
         dictgen::InsensitiveStr::Ascii("uge"),
@@ -122012,12 +122012,12 @@ pub static WORD_INDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_INDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INDI_CHILDREN),
+static WORD_INDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INDI_CHILDREN),
     value: None,
 };
 
-static WORD_INDI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INDI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INDIA_NODE),
     None,
     Some(&WORD_INDIC_NODE),
@@ -122046,23 +122046,23 @@ static WORD_INDI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_INDIZ_NODE),
 ];
 
-static WORD_INDIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIZ_CHILDREN),
+static WORD_INDIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["indices"]],
     range: 3..=3,
 };
 
-static WORD_INDIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIV_CHILDREN),
+static WORD_INDIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dual"),
         dictgen::InsensitiveStr::Ascii("dually"),
@@ -122170,12 +122170,12 @@ pub static WORD_INDIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INDIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIS_CHILDREN),
+static WORD_INDIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crimnate"),
         dictgen::InsensitiveStr::Ascii("ious"),
@@ -122207,12 +122207,12 @@ pub static WORD_INDIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_INDIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIR_CHILDREN),
+static WORD_INDIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eclty"),
         dictgen::InsensitiveStr::Ascii("ectely"),
@@ -122228,12 +122228,12 @@ pub static WORD_INDIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INDIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIQ_CHILDREN),
+static WORD_INDIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uate"),
         dictgen::InsensitiveStr::Ascii("uates"),
@@ -122242,12 +122242,12 @@ pub static WORD_INDIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_INDIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIP_CHILDREN),
+static WORD_INDIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("endence"),
         dictgen::InsensitiveStr::Ascii("endent"),
@@ -122257,12 +122257,12 @@ pub static WORD_INDIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_INDIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIM_CHILDREN),
+static WORD_INDIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idating"),
         dictgen::InsensitiveStr::Ascii("idation"),
@@ -122271,23 +122271,23 @@ pub static WORD_INDIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_INDIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIK_CHILDREN),
+static WORD_INDIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["indication"]],
     range: 5..=5,
 };
 
-static WORD_INDIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIG_CHILDREN),
+static WORD_INDIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eneous"),
         dictgen::InsensitiveStr::Ascii("enious"),
@@ -122311,12 +122311,12 @@ pub static WORD_INDIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INDIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIF_CHILDREN),
+static WORD_INDIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ferance"),
         dictgen::InsensitiveStr::Ascii("ferant"),
@@ -122336,12 +122336,12 @@ pub static WORD_INDIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INDIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIE_CHILDREN),
+static WORD_INDIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -122350,23 +122350,23 @@ pub static WORD_INDIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_INDID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDID_CHILDREN),
+static WORD_INDID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDID_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["inside", "indeed"]],
     range: 1..=1,
 };
 
-static WORD_INDIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIC_CHILDREN),
+static WORD_INDIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aite"),
         dictgen::InsensitiveStr::Ascii("aste"),
@@ -122444,12 +122444,12 @@ pub static WORD_INDIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INDIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIA_CHILDREN),
+static WORD_INDIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("cte"),
@@ -122487,12 +122487,12 @@ pub static WORD_INDIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_INDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INDE_CHILDREN),
+static WORD_INDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INDE_CHILDREN),
     value: None,
 };
 
-static WORD_INDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INDE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_INDEC_NODE),
@@ -122521,12 +122521,12 @@ static WORD_INDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INDEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEX_CHILDREN),
+static WORD_INDEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ig"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -122536,12 +122536,12 @@ pub static WORD_INDEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_INDEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEV_CHILDREN),
+static WORD_INDEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -122559,12 +122559,12 @@ pub static WORD_INDEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INDET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDET_CHILDREN),
+static WORD_INDET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDET_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifiable"),
         dictgen::InsensitiveStr::Ascii("ification"),
@@ -122573,12 +122573,12 @@ pub static WORD_INDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_INDES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDES_CHILDREN),
+static WORD_INDES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDES_CHILDREN),
     value: Some(&["index"]),
 };
 
-pub static WORD_INDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("criminent"),
         dictgen::InsensitiveStr::Ascii("pensable"),
@@ -122600,12 +122600,12 @@ pub static WORD_INDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_INDER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDER_CHILDREN),
+static WORD_INDER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDER_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ictly"),
@@ -122615,12 +122615,12 @@ pub static WORD_INDER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INDEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INDEP_CHILDREN),
+static WORD_INDEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INDEP_CHILDREN),
     value: None,
 };
 
-static WORD_INDEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INDEP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INDEPA_NODE),
     None,
     None,
@@ -122649,12 +122649,12 @@ static WORD_INDEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INDEPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEPE_CHILDREN),
+static WORD_INDEPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dantly"),
         dictgen::InsensitiveStr::Ascii("dence"),
@@ -122764,12 +122764,12 @@ pub static WORD_INDEPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_INDEPD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEPD_CHILDREN),
+static WORD_INDEPD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEPD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEPD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("encente"),
@@ -122813,23 +122813,23 @@ pub static WORD_INDEPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_INDEPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEPA_CHILDREN),
+static WORD_INDEPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ndance")],
     values: &[&["independence"]],
     range: 6..=6,
 };
 
-static WORD_INDEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEN_CHILDREN),
+static WORD_INDEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dation"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -122881,34 +122881,34 @@ pub static WORD_INDEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INDEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEM_CHILDREN),
+static WORD_INDEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("potent")],
     values: &[&["idempotent"]],
     range: 6..=6,
 };
 
-static WORD_INDEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEG_CHILDREN),
+static WORD_INDEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inous")],
     values: &[&["indigenous"]],
     range: 5..=5,
 };
 
-static WORD_INDEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEF_CHILDREN),
+static WORD_INDEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enite"),
         dictgen::InsensitiveStr::Ascii("inate"),
@@ -122952,23 +122952,23 @@ pub static WORD_INDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_INDED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDED_CHILDREN),
+static WORD_INDED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDED_CHILDREN),
     value: Some(&["indeed", "index"]),
 };
 
-pub static WORD_INDED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_INDEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEC_CHILDREN),
+static WORD_INDEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -122979,12 +122979,12 @@ pub static WORD_INDEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_INDD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDD_CHILDREN),
+static WORD_INDD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ex"),
         dictgen::InsensitiveStr::Ascii("ividual"),
@@ -123000,12 +123000,12 @@ pub static WORD_INDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDC_CHILDREN),
+static WORD_INDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -123014,12 +123014,12 @@ pub static WORD_INDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_INDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDA_CHILDREN),
+static WORD_INDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("equate"),
         dictgen::InsensitiveStr::Ascii("ins"),
@@ -123035,12 +123035,12 @@ pub static WORD_INDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INC_CHILDREN),
+static WORD_INC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INC_CHILDREN),
     value: None,
 };
 
-static WORD_INC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INCA_NODE),
     None,
     None,
@@ -123069,23 +123069,23 @@ static WORD_INC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCV_CHILDREN),
+static WORD_INCV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("alid")],
     values: &[&["invalid"]],
     range: 4..=4,
 };
 
-static WORD_INCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCU_CHILDREN),
+static WORD_INCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -123123,12 +123123,12 @@ pub static WORD_INCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCT_CHILDREN),
+static WORD_INCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("roduce"),
@@ -123138,12 +123138,12 @@ pub static WORD_INCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_INCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCR_CHILDREN),
+static WORD_INCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCR_CHILDREN),
     value: None,
 };
 
-static WORD_INCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INCRA_NODE),
     None,
     None,
@@ -123172,23 +123172,23 @@ static WORD_INCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRO_CHILDREN),
+static WORD_INCRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mpehensible")],
     values: &[&["incomprehensible"]],
     range: 11..=11,
 };
 
-static WORD_INCRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRM_CHILDREN),
+static WORD_INCRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enet"),
         dictgen::InsensitiveStr::Ascii("enetd"),
@@ -123214,12 +123214,12 @@ pub static WORD_INCRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INCRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRI_CHILDREN),
+static WORD_INCRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mental"),
         dictgen::InsensitiveStr::Ascii("ments"),
@@ -123228,23 +123228,23 @@ pub static WORD_INCRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_INCRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRF_CHILDREN),
+static WORD_INCRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("emental")],
     values: &[&["incremental"]],
     range: 7..=7,
 };
 
-static WORD_INCRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRE_CHILDREN),
+static WORD_INCRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adible"),
         dictgen::InsensitiveStr::Ascii("ading"),
@@ -123350,12 +123350,12 @@ pub static WORD_INCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INCRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRA_CHILDREN),
+static WORD_INCRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mental"),
         dictgen::InsensitiveStr::Ascii("mentally"),
@@ -123371,23 +123371,23 @@ pub static WORD_INCRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_INCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCP_CHILDREN),
+static WORD_INCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etion")],
     values: &[&["inception"]],
     range: 5..=5,
 };
 
-static WORD_INCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCO_CHILDREN),
+static WORD_INCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCO_CHILDREN),
     value: None,
 };
 
-static WORD_INCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -123416,12 +123416,12 @@ static WORD_INCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOV_CHILDREN),
+static WORD_INCOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enience"),
         dictgen::InsensitiveStr::Ascii("ience"),
@@ -123430,12 +123430,12 @@ pub static WORD_INCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INCOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOS_CHILDREN),
+static WORD_INCOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("istencies"),
         dictgen::InsensitiveStr::Ascii("istency"),
@@ -123451,12 +123451,12 @@ pub static WORD_INCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_INCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOR_CHILDREN),
+static WORD_INCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ectly"),
@@ -123532,12 +123532,12 @@ pub static WORD_INCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_INCOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOP_CHILDREN),
+static WORD_INCOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erate"),
         dictgen::InsensitiveStr::Ascii("erated"),
@@ -123569,23 +123569,23 @@ pub static WORD_INCOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_INCOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOO_CHILDREN),
+static WORD_INCOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("perates")],
     values: &[&["incorporates"]],
     range: 7..=7,
 };
 
-static WORD_INCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCON_CHILDREN),
+static WORD_INCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCON_CHILDREN),
     value: None,
 };
 
-static WORD_INCON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_INCONC_NODE),
@@ -123614,12 +123614,12 @@ static WORD_INCON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCONV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONV_CHILDREN),
+static WORD_INCONV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eience"),
         dictgen::InsensitiveStr::Ascii("eince"),
@@ -123697,23 +123697,23 @@ pub static WORD_INCONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_INCONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONT_CHILDREN),
+static WORD_INCONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rollably")],
     values: &[&["uncontrollably"]],
     range: 8..=8,
 };
 
-static WORD_INCONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONS_CHILDREN),
+static WORD_INCONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciously"),
         dictgen::InsensitiveStr::Ascii("ecuential"),
@@ -123803,34 +123803,34 @@ pub static WORD_INCONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_INCONP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONP_CHILDREN),
+static WORD_INCONP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rehensible")],
     values: &[&["incomprehensible"]],
     range: 10..=10,
 };
 
-static WORD_INCONL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONL_CHILDREN),
+static WORD_INCONL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("usive")],
     values: &[&["inconclusive"]],
     range: 5..=5,
 };
 
-static WORD_INCONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONI_CHILDREN),
+static WORD_INCONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sistent"),
         dictgen::InsensitiveStr::Ascii("stencies"),
@@ -123839,23 +123839,23 @@ pub static WORD_INCONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=8,
 };
 
-static WORD_INCONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONG_CHILDREN),
+static WORD_INCONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ito")],
     values: &[&["incognito"]],
     range: 3..=3,
 };
 
-static WORD_INCONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONF_CHILDREN),
+static WORD_INCONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ortable"),
@@ -123864,12 +123864,12 @@ pub static WORD_INCONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_INCOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOND_CHILDREN),
+static WORD_INCOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itional"),
         dictgen::InsensitiveStr::Ascii("itionally"),
@@ -123878,12 +123878,12 @@ pub static WORD_INCOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=9,
 };
 
-static WORD_INCONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONC_CHILDREN),
+static WORD_INCONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("equential"),
         dictgen::InsensitiveStr::Ascii("iderate"),
@@ -123901,12 +123901,12 @@ pub static WORD_INCONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=9,
 };
 
-static WORD_INCOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCOM_CHILDREN),
+static WORD_INCOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCOM_CHILDREN),
     value: None,
 };
 
-static WORD_INCOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCOM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INCOMA_NODE),
     Some(&WORD_INCOMB_NODE),
     None,
@@ -123935,12 +123935,12 @@ static WORD_INCOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCOMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCOMP_CHILDREN),
+static WORD_INCOMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCOMP_CHILDREN),
     value: None,
 };
 
-static WORD_INCOMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCOMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INCOMPA_NODE),
     None,
     None,
@@ -123969,12 +123969,12 @@ static WORD_INCOMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCOMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPT_CHILDREN),
+static WORD_INCOMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("etent"),
@@ -123984,12 +123984,12 @@ pub static WORD_INCOMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=5,
 };
 
-static WORD_INCOMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPR_CHILDREN),
+static WORD_INCOMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ehencible"),
         dictgen::InsensitiveStr::Ascii("ehendible"),
@@ -124013,23 +124013,23 @@ pub static WORD_INCOMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 8..=9,
 };
 
-static WORD_INCOMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPO_CHILDREN),
+static WORD_INCOMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tent")],
     values: &[&["incompetent"]],
     range: 4..=4,
 };
 
-static WORD_INCOMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPL_CHILDREN),
+static WORD_INCOMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eate"),
         dictgen::InsensitiveStr::Ascii("eete"),
@@ -124039,12 +124039,12 @@ pub static WORD_INCOMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_INCOMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPI_CHILDREN),
+static WORD_INCOMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("table"),
@@ -124054,12 +124054,12 @@ pub static WORD_INCOMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=5,
 };
 
-static WORD_INCOMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPE_CHILDREN),
+static WORD_INCOMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tance"),
         dictgen::InsensitiveStr::Ascii("tant"),
@@ -124077,12 +124077,12 @@ pub static WORD_INCOMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_INCOMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPA_CHILDREN),
+static WORD_INCOMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -124178,23 +124178,23 @@ pub static WORD_INCOMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=10,
 };
 
-static WORD_INCOMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMN_CHILDREN),
+static WORD_INCOMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["incoming"]],
     range: 1..=1,
 };
 
-static WORD_INCOMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMM_CHILDREN),
+static WORD_INCOMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("plete"),
@@ -124203,12 +124203,12 @@ pub static WORD_INCOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_INCOMF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMF_CHILDREN),
+static WORD_INCOMF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ortable"),
@@ -124222,12 +124222,12 @@ pub static WORD_INCOMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_INCOMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMB_CHILDREN),
+static WORD_INCOMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atibilities"),
         dictgen::InsensitiveStr::Ascii("atibility"),
@@ -124236,12 +124236,12 @@ pub static WORD_INCOMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 9..=11,
 };
 
-static WORD_INCOMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMA_CHILDREN),
+static WORD_INCOMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("patibility"),
         dictgen::InsensitiveStr::Ascii("patible"),
@@ -124263,12 +124263,12 @@ pub static WORD_INCOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=11,
 };
 
-static WORD_INCOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOH_CHILDREN),
+static WORD_INCOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erance"),
         dictgen::InsensitiveStr::Ascii("erancy"),
@@ -124288,12 +124288,12 @@ pub static WORD_INCOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INCOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOG_CHILDREN),
+static WORD_INCOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("into"),
         dictgen::InsensitiveStr::Ascii("nitio"),
@@ -124303,23 +124303,23 @@ pub static WORD_INCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INCM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCM_CHILDREN),
+static WORD_INCM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rement")],
     values: &[&["increment"]],
     range: 6..=6,
 };
 
-static WORD_INCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCL_CHILDREN),
+static WORD_INCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anation"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -124415,12 +124415,12 @@ pub static WORD_INCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_INCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCI_CHILDREN),
+static WORD_INCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dencies"),
         dictgen::InsensitiveStr::Ascii("dentaly"),
@@ -124444,34 +124444,34 @@ pub static WORD_INCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCH_CHILDREN),
+static WORD_INCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oerent")],
     values: &[&["incoherent"]],
     range: 6..=6,
 };
 
-static WORD_INCG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCG_CHILDREN),
+static WORD_INCG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onito")],
     values: &[&["incognito"]],
     range: 5..=5,
 };
 
-static WORD_INCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCE_CHILDREN),
+static WORD_INCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dent"),
         dictgen::InsensitiveStr::Ascii("dentally"),
@@ -124517,12 +124517,12 @@ pub static WORD_INCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_INCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCA_CHILDREN),
+static WORD_INCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lid"),
         dictgen::InsensitiveStr::Ascii("rantion"),
@@ -124560,12 +124560,12 @@ pub static WORD_INCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INB_CHILDREN),
+static WORD_INB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alance"),
         dictgen::InsensitiveStr::Ascii("alanced"),
@@ -124623,12 +124623,12 @@ pub static WORD_INB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_INA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INA_CHILDREN),
+static WORD_INA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INA_CHILDREN),
     value: None,
 };
 
-static WORD_INA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_INAB_NODE),
     Some(&WORD_INAC_NODE),
@@ -124657,12 +124657,12 @@ static WORD_INA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAV_CHILDREN),
+static WORD_INAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lid"),
         dictgen::InsensitiveStr::Ascii("lis"),
@@ -124671,23 +124671,23 @@ pub static WORD_INAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_INAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAU_CHILDREN),
+static WORD_INAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gures")],
     values: &[&["inaugurates"]],
     range: 5..=5,
 };
 
-static WORD_INAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAT_CHILDREN),
+static WORD_INAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ruction"),
@@ -124697,12 +124697,12 @@ pub static WORD_INAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_INAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAP_CHILDREN),
+static WORD_INAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("porpriate"),
         dictgen::InsensitiveStr::Ascii("porpriately"),
@@ -124746,45 +124746,45 @@ pub static WORD_INAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=12,
 };
 
-static WORD_INAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAL_CHILDREN),
+static WORD_INAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("id")],
     values: &[&["invalid"]],
     range: 2..=2,
 };
 
-static WORD_INAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAK_CHILDREN),
+static WORD_INAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tively")],
     values: &[&["inactively"]],
     range: 6..=6,
 };
 
-static WORD_INAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAH_CHILDREN),
+static WORD_INAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bitants")],
     values: &[&["inhabitants"]],
     range: 7..=7,
 };
 
-static WORD_INAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAG_CHILDREN),
+static WORD_INAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("urated"),
         dictgen::InsensitiveStr::Ascii("uration"),
@@ -124793,12 +124793,12 @@ pub static WORD_INAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_INAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAD_CHILDREN),
+static WORD_INAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aquate"),
         dictgen::InsensitiveStr::Ascii("aquete"),
@@ -124842,12 +124842,12 @@ pub static WORD_INAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_INAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAC_CHILDREN),
+static WORD_INAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccessible"),
         dictgen::InsensitiveStr::Ascii("cesible"),
@@ -124901,12 +124901,12 @@ pub static WORD_INAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAB_CHILDREN),
+static WORD_INAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -124924,12 +124924,12 @@ pub static WORD_INAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_IM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IM_CHILDREN),
+static WORD_IM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IM_CHILDREN),
     value: None,
 };
 
-static WORD_IM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMA_NODE),
     Some(&WORD_IMB_NODE),
     Some(&WORD_IMC_NODE),
@@ -124958,12 +124958,12 @@ static WORD_IM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMT_CHILDREN),
+static WORD_IMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imidating"),
         dictgen::InsensitiveStr::Ascii("imidation"),
@@ -124972,23 +124972,23 @@ pub static WORD_IMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=9,
 };
 
-static WORD_IMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMS_CHILDREN),
+static WORD_IMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ensitive")],
     values: &[&["insensitive"]],
     range: 8..=8,
 };
 
-static WORD_IMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMR_CHILDREN),
+static WORD_IMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ovement"),
         dictgen::InsensitiveStr::Ascii("pove"),
@@ -125012,12 +125012,12 @@ pub static WORD_IMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_IMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMP_CHILDREN),
+static WORD_IMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMP_CHILDREN),
     value: None,
 };
 
-static WORD_IMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPA_NODE),
     None,
     Some(&WORD_IMPC_NODE),
@@ -125046,12 +125046,12 @@ static WORD_IMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPU_CHILDREN),
+static WORD_IMPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("les"),
         dictgen::InsensitiveStr::Ascii("lisve"),
@@ -125087,12 +125087,12 @@ pub static WORD_IMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_IMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPR_CHILDREN),
+static WORD_IMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPR_CHILDREN),
     value: None,
 };
 
-static WORD_IMPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPRA_NODE),
     None,
     None,
@@ -125121,34 +125121,34 @@ static WORD_IMPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRT_CHILDREN),
+static WORD_IMPRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ant")],
     values: &[&["important"]],
     range: 3..=3,
 };
 
-static WORD_IMPRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRS_CHILDREN),
+static WORD_IMPRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ioned")],
     values: &[&["imprisoned"]],
     range: 5..=5,
 };
 
-static WORD_IMPRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRO_CHILDREN),
+static WORD_IMPRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("babe"),
         dictgen::InsensitiveStr::Ascii("babil"),
@@ -125278,12 +125278,12 @@ pub static WORD_IMPRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_IMPRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRI_CHILDREN),
+static WORD_IMPRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oned"),
         dictgen::InsensitiveStr::Ascii("sonent"),
@@ -125293,12 +125293,12 @@ pub static WORD_IMPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_IMPRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRE_CHILDREN),
+static WORD_IMPRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("fect"),
@@ -125338,12 +125338,12 @@ pub static WORD_IMPRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_IMPRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRA_CHILDREN),
+static WORD_IMPRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctial"),
         dictgen::InsensitiveStr::Ascii("cticle"),
@@ -125352,12 +125352,12 @@ pub static WORD_IMPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_IMPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPP_CHILDREN),
+static WORD_IMPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lement"),
         dictgen::InsensitiveStr::Ascii("lementating"),
@@ -125373,12 +125373,12 @@ pub static WORD_IMPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=11,
 };
 
-static WORD_IMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPO_CHILDREN),
+static WORD_IMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPO_CHILDREN),
     value: None,
 };
 
-static WORD_IMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -125407,12 +125407,12 @@ static WORD_IMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOV_CHILDREN),
+static WORD_IMPOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -125438,12 +125438,12 @@ pub static WORD_IMPOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_IMPOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOT_CHILDREN),
+static WORD_IMPOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOT_CHILDREN),
     value: Some(&["import"]),
 };
 
-pub static WORD_IMPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -125457,12 +125457,12 @@ pub static WORD_IMPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_IMPOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOS_CHILDREN),
+static WORD_IMPOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ible"),
         dictgen::InsensitiveStr::Ascii("sable"),
@@ -125504,12 +125504,12 @@ pub static WORD_IMPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_IMPOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOR_CHILDREN),
+static WORD_IMPOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("atant"),
@@ -125609,23 +125609,23 @@ pub static WORD_IMPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_IMPOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOL_CHILDREN),
+static WORD_IMPOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("de")],
     values: &[&["implode"]],
     range: 2..=2,
 };
 
-static WORD_IMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPL_CHILDREN),
+static WORD_IMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPL_CHILDREN),
     value: None,
 };
 
-static WORD_IMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPLA_NODE),
     None,
     Some(&WORD_IMPLC_NODE),
@@ -125654,12 +125654,12 @@ static WORD_IMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLU_CHILDREN),
+static WORD_IMPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -125669,12 +125669,12 @@ pub static WORD_IMPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_IMPLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLO_CHILDREN),
+static WORD_IMPLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("sed"),
@@ -125684,12 +125684,12 @@ pub static WORD_IMPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_IMPLM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLM_CHILDREN),
+static WORD_IMPLM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLM_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eentation"),
         dictgen::InsensitiveStr::Ascii("enet"),
@@ -125731,12 +125731,12 @@ pub static WORD_IMPLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_IMPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLI_CHILDREN),
+static WORD_IMPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cacion"),
         dictgen::InsensitiveStr::Ascii("cati"),
@@ -125810,12 +125810,12 @@ pub static WORD_IMPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_IMPLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPLE_CHILDREN),
+static WORD_IMPLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPLE_CHILDREN),
     value: None,
 };
 
-static WORD_IMPLE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPLE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_IMPLEC_NODE),
@@ -125844,12 +125844,12 @@ static WORD_IMPLE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLET_CHILDREN),
+static WORD_IMPLET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLET_CHILDREN),
     value: Some(&["implement"]),
 };
 
-pub static WORD_IMPLET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -125871,12 +125871,12 @@ pub static WORD_IMPLET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_IMPLEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEN_CHILDREN),
+static WORD_IMPLEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eted"),
         dictgen::InsensitiveStr::Ascii("ment"),
@@ -125904,12 +125904,12 @@ pub static WORD_IMPLEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_IMPLEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEM_CHILDREN),
+static WORD_IMPLEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPLEM_CHILDREN),
     value: None,
 };
 
-static WORD_IMPLEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPLEM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPLEMA_NODE),
     None,
     None,
@@ -125938,12 +125938,12 @@ static WORD_IMPLEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLEMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMT_CHILDREN),
+static WORD_IMPLEMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMT_CHILDREN),
     value: Some(&["implement"]),
 };
 
-pub static WORD_IMPLEMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -125965,12 +125965,12 @@ pub static WORD_IMPLEMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_IMPLEMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMN_CHILDREN),
+static WORD_IMPLEMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etation"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -125988,12 +125988,12 @@ pub static WORD_IMPLEMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_IMPLEME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEME_CHILDREN),
+static WORD_IMPLEME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPLEME_CHILDREN),
     value: None,
 };
 
-static WORD_IMPLEME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPLEME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -126022,12 +126022,12 @@ static WORD_IMPLEME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLEMET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMET_CHILDREN),
+static WORD_IMPLEMET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMET_CHILDREN),
     value: Some(&["implements", "implement"]),
 };
 
-pub static WORD_IMPLEMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -126049,12 +126049,12 @@ pub static WORD_IMPLEMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=6,
 };
 
-static WORD_IMPLEMEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEMEN_CHILDREN),
+static WORD_IMPLEMEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPLEMEN_CHILDREN),
     value: Some(&["implement"]),
 };
 
-static WORD_IMPLEMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPLEMEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPLEMENA_NODE),
     None,
     Some(&WORD_IMPLEMENC_NODE),
@@ -126083,12 +126083,12 @@ static WORD_IMPLEMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLEMENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENT_CHILDREN),
+static WORD_IMPLEMENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("aciones"),
@@ -126190,34 +126190,34 @@ pub static WORD_IMPLEMENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=8,
 };
 
-static WORD_IMPLEMENR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENR_CHILDREN),
+static WORD_IMPLEMENR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["implement"]],
     range: 1..=1,
 };
 
-static WORD_IMPLEMENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENI_CHILDREN),
+static WORD_IMPLEMENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["implementing"]],
     range: 2..=2,
 };
 
-static WORD_IMPLEMENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENE_CHILDREN),
+static WORD_IMPLEMENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -126249,34 +126249,34 @@ pub static WORD_IMPLEMENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=7,
 };
 
-static WORD_IMPLEMEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMEND_CHILDREN),
+static WORD_IMPLEMEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMEND_CHILDREN),
     value: Some(&["implement"]),
 };
 
-pub static WORD_IMPLEMEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["implements"]],
     range: 1..=1,
 };
 
-static WORD_IMPLEMENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENC_CHILDREN),
+static WORD_IMPLEMENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["implemented"]],
     range: 3..=3,
 };
 
-static WORD_IMPLEMENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENA_CHILDREN),
+static WORD_IMPLEMENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tation"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -126294,12 +126294,12 @@ pub static WORD_IMPLEMENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 4..=6,
 };
 
-static WORD_IMPLEMEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMEM_CHILDREN),
+static WORD_IMPLEMEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emnt"),
         dictgen::InsensitiveStr::Ascii("emntation"),
@@ -126339,12 +126339,12 @@ pub static WORD_IMPLEMEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=9,
 };
 
-static WORD_IMPLEMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMA_CHILDREN),
+static WORD_IMPLEMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntation"),
         dictgen::InsensitiveStr::Ascii("taion"),
@@ -126358,23 +126358,23 @@ pub static WORD_IMPLEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=7,
 };
 
-static WORD_IMPLEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEI_CHILDREN),
+static WORD_IMPLEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ment")],
     values: &[&["implement"]],
     range: 4..=4,
 };
 
-static WORD_IMPLEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEE_CHILDREN),
+static WORD_IMPLEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mntation"),
         dictgen::InsensitiveStr::Ascii("mntations"),
@@ -126383,23 +126383,23 @@ pub static WORD_IMPLEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 8..=9,
 };
 
-static WORD_IMPLEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEC_CHILDREN),
+static WORD_IMPLEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ations")],
     values: &[&["implications"]],
     range: 6..=6,
 };
 
-static WORD_IMPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLC_CHILDREN),
+static WORD_IMPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("itly"),
@@ -126409,12 +126409,12 @@ pub static WORD_IMPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_IMPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLA_CHILDREN),
+static WORD_IMPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -126450,12 +126450,12 @@ pub static WORD_IMPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_IMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPI_CHILDREN),
+static WORD_IMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("citly"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -126465,12 +126465,12 @@ pub static WORD_IMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_IMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPE_CHILDREN),
+static WORD_IMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ared"),
         dictgen::InsensitiveStr::Ascii("cabbly"),
@@ -126584,12 +126584,12 @@ pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_IMPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPC_CHILDREN),
+static WORD_IMPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -126600,12 +126600,12 @@ pub static WORD_IMPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_IMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPA_CHILDREN),
+static WORD_IMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cte"),
         dictgen::InsensitiveStr::Ascii("ctes"),
@@ -126627,12 +126627,12 @@ pub static WORD_IMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_IMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMO_CHILDREN),
+static WORD_IMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilisation"),
         dictgen::InsensitiveStr::Ascii("licit"),
@@ -126662,23 +126662,23 @@ pub static WORD_IMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_IMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMN_CHILDREN),
+static WORD_IMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["image"]],
     range: 3..=3,
 };
 
-static WORD_IMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMM_CHILDREN),
+static WORD_IMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMM_CHILDREN),
     value: None,
 };
 
-static WORD_IMM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMMA_NODE),
     Some(&WORD_IMMB_NODE),
     None,
@@ -126707,12 +126707,12 @@ static WORD_IMM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMU_CHILDREN),
+static WORD_IMMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("niy"),
         dictgen::InsensitiveStr::Ascii("nosupressant"),
@@ -126722,12 +126722,12 @@ pub static WORD_IMMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_IMMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMS_CHILDREN),
+static WORD_IMMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erive"),
         dictgen::InsensitiveStr::Ascii("ersive"),
@@ -126737,12 +126737,12 @@ pub static WORD_IMMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_IMMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMO_CHILDREN),
+static WORD_IMMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilie"),
         dictgen::InsensitiveStr::Ascii("bilien"),
@@ -126790,12 +126790,12 @@ pub static WORD_IMMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_IMMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMM_CHILDREN),
+static WORD_IMMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ediate"),
         dictgen::InsensitiveStr::Ascii("ediately"),
@@ -126804,12 +126804,12 @@ pub static WORD_IMMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_IMMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMI_CHILDREN),
+static WORD_IMMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dately"),
         dictgen::InsensitiveStr::Ascii("datly"),
@@ -126851,12 +126851,12 @@ pub static WORD_IMMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_IMME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMME_CHILDREN),
+static WORD_IMME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMME_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adiate"),
         dictgen::InsensitiveStr::Ascii("adiately"),
@@ -126940,23 +126940,23 @@ pub static WORD_IMME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_IMMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMB_CHILDREN),
+static WORD_IMMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oile")],
     values: &[&["immobile"]],
     range: 4..=4,
 };
 
-static WORD_IMMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMA_CHILDREN),
+static WORD_IMMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("diate"),
         dictgen::InsensitiveStr::Ascii("diately"),
@@ -126980,12 +126980,12 @@ pub static WORD_IMMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_IML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IML_CHILDREN),
+static WORD_IML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IML_CHILDREN),
     value: None,
 };
 
-pub static WORD_IML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ementation"),
@@ -127021,12 +127021,12 @@ pub static WORD_IML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_IMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMI_CHILDREN),
+static WORD_IMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("diately"),
         dictgen::InsensitiveStr::Ascii("grant"),
@@ -127048,12 +127048,12 @@ pub static WORD_IMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_IMG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMG_CHILDREN),
+static WORD_IMG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMG_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -127063,12 +127063,12 @@ pub static WORD_IMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_IMF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMF_CHILDREN),
+static WORD_IMF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMF_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amus"),
         dictgen::InsensitiveStr::Ascii("ormation"),
@@ -127077,12 +127077,12 @@ pub static WORD_IMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_IME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IME_CHILDREN),
+static WORD_IME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IME_CHILDREN),
     value: None,
 };
 
-pub static WORD_IME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adiatly"),
         dictgen::InsensitiveStr::Ascii("datly"),
@@ -127106,12 +127106,12 @@ pub static WORD_IME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_IMC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMC_CHILDREN),
+static WORD_IMC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oming"),
         dictgen::InsensitiveStr::Ascii("omming"),
@@ -127133,12 +127133,12 @@ pub static WORD_IMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=13,
 };
 
-static WORD_IMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMB_CHILDREN),
+static WORD_IMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alanaced"),
         dictgen::InsensitiveStr::Ascii("alanaces"),
@@ -127180,12 +127180,12 @@ pub static WORD_IMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_IMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMA_CHILDREN),
+static WORD_IMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blanced"),
         dictgen::InsensitiveStr::Ascii("blances"),
@@ -127243,12 +127243,12 @@ pub static WORD_IMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_IL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IL_CHILDREN),
+static WORD_IL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IL_CHILDREN),
     value: None,
 };
 
-static WORD_IL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ILA_NODE),
     None,
     None,
@@ -127277,12 +127277,12 @@ static WORD_IL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ILU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILU_CHILDREN),
+static WORD_ILU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("minate"),
         dictgen::InsensitiveStr::Ascii("minated"),
@@ -127306,45 +127306,45 @@ pub static WORD_ILU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_ILT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILT_CHILDREN),
+static WORD_ILT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erate")],
     values: &[&["literate"]],
     range: 5..=5,
 };
 
-static WORD_ILO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILO_CHILDREN),
+static WORD_ILO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gical")],
     values: &[&["illogical"]],
     range: 5..=5,
 };
 
-static WORD_ILN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILN_CHILDREN),
+static WORD_ILN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["illness"]],
     range: 3..=3,
 };
 
-static WORD_ILL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ILL_CHILDREN),
+static WORD_ILL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ILL_CHILDREN),
     value: None,
 };
 
-static WORD_ILL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ILL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -127373,12 +127373,12 @@ static WORD_ILL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ILLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLU_CHILDREN),
+static WORD_ILLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("manati"),
         dictgen::InsensitiveStr::Ascii("maniti"),
@@ -127476,12 +127476,12 @@ pub static WORD_ILLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_ILLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLS_CHILDREN),
+static WORD_ILLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uions"),
         dictgen::InsensitiveStr::Ascii("utration"),
@@ -127491,12 +127491,12 @@ pub static WORD_ILLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ILLN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLN_CHILDREN),
+static WORD_ILLN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esess"),
         dictgen::InsensitiveStr::Ascii("esss"),
@@ -127505,12 +127505,12 @@ pub static WORD_ILLN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_ILLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLI_CHILDREN),
+static WORD_ILLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egal"),
         dictgen::InsensitiveStr::Ascii("gal"),
@@ -127550,23 +127550,23 @@ pub static WORD_ILLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ILLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLG_CHILDREN),
+static WORD_ILLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["illegal"]],
     range: 2..=2,
 };
 
-static WORD_ILLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLE_CHILDREN),
+static WORD_ILLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gales"),
         dictgen::InsensitiveStr::Ascii("galest"),
@@ -127614,23 +127614,23 @@ pub static WORD_ILLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ILI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILI_CHILDREN),
+static WORD_ILI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gal")],
     values: &[&["illegal"]],
     range: 3..=3,
 };
 
-static WORD_ILE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILE_CHILDREN),
+static WORD_ILE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agle"),
         dictgen::InsensitiveStr::Ascii("gal"),
@@ -127641,23 +127641,23 @@ pub static WORD_ILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ILA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILA_CHILDREN),
+static WORD_ILA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nd")],
     values: &[&["island"]],
     range: 2..=2,
 };
 
-static WORD_II_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_II_CHILDREN),
+static WORD_II_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_II_CHILDREN),
     value: None,
 };
 
-pub static WORD_II_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_II_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("mmune"),
@@ -127679,12 +127679,12 @@ pub static WORD_II_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_IH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IH_CHILDREN),
+static WORD_IH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IH_CHILDREN),
     value: None,
 };
 
-pub static WORD_IH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aca"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -127693,12 +127693,12 @@ pub static WORD_IH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_IG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IG_CHILDREN),
+static WORD_IG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IG_CHILDREN),
     value: None,
 };
 
-static WORD_IG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -127727,12 +127727,12 @@ static WORD_IG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_IGZ_NODE),
 ];
 
-static WORD_IGZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IGZ_CHILDREN),
+static WORD_IGZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IGZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_IGZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IGZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("orted"),
@@ -127750,23 +127750,23 @@ pub static WORD_IGZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_IGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IGR_CHILDREN),
+static WORD_IGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nore")],
     values: &[&["ignore"]],
     range: 4..=4,
 };
 
-static WORD_IGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IGO_CHILDREN),
+static WORD_IGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IGO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IGO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ned"),
         dictgen::InsensitiveStr::Ascii("norando"),
@@ -127792,12 +127792,12 @@ pub static WORD_IGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_IGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IGN_CHILDREN),
+static WORD_IGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_IGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ested"),
@@ -127927,12 +127927,12 @@ pub static WORD_IGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_IF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IF_CHILDREN),
+static WORD_IF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IF_CHILDREN),
     value: None,
 };
 
-pub static WORD_IF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("normation"),
@@ -127943,12 +127943,12 @@ pub static WORD_IF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_IE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IE_CHILDREN),
+static WORD_IE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chart"),
         dictgen::InsensitiveStr::Ascii("rland"),
@@ -127958,12 +127958,12 @@ pub static WORD_IE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_ID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ID_CHILDREN),
+static WORD_ID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ID_CHILDREN),
     value: None,
 };
 
-static WORD_ID_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ID_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IDA_NODE),
     None,
     None,
@@ -127992,23 +127992,23 @@ static WORD_ID_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDO_CHILDREN),
+static WORD_IDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ns")],
     values: &[&["icons"]],
     range: 2..=2,
 };
 
-static WORD_IDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDI_CHILDREN),
+static WORD_IDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -128054,12 +128054,12 @@ pub static WORD_IDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_IDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IDE_CHILDREN),
+static WORD_IDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IDE_CHILDREN),
     value: None,
 };
 
-static WORD_IDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IDE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IDEA_NODE),
     None,
     None,
@@ -128088,12 +128088,12 @@ static WORD_IDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IDET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDET_CHILDREN),
+static WORD_IDET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDET_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifier"),
         dictgen::InsensitiveStr::Ascii("ifiers"),
@@ -128109,23 +128109,23 @@ pub static WORD_IDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_IDES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDES_CHILDREN),
+static WORD_IDES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDES_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("a")],
     values: &[&["ideas", "ides"]],
     range: 1..=1,
 };
 
-static WORD_IDEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEP_CHILDREN),
+static WORD_IDEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("endent"),
         dictgen::InsensitiveStr::Ascii("endently"),
@@ -128135,12 +128135,12 @@ pub static WORD_IDEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_IDEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEO_CHILDREN),
+static WORD_IDEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lagies"),
         dictgen::InsensitiveStr::Ascii("ligically"),
@@ -128192,12 +128192,12 @@ pub static WORD_IDEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_IDEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IDEN_CHILDREN),
+static WORD_IDEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IDEN_CHILDREN),
     value: None,
 };
 
-static WORD_IDEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IDEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -128226,12 +128226,12 @@ static WORD_IDEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IDENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDENT_CHILDREN),
+static WORD_IDENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cal"),
@@ -128365,23 +128365,23 @@ pub static WORD_IDENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_IDENP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDENP_CHILDREN),
+static WORD_IDENP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDENP_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDENP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDENP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enendtly")],
     values: &[&["independently"]],
     range: 8..=8,
 };
 
-static WORD_IDENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDENI_CHILDREN),
+static WORD_IDENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fiable"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -128411,12 +128411,12 @@ pub static WORD_IDENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_IDENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDENF_CHILDREN),
+static WORD_IDENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ier"),
@@ -128440,12 +128440,12 @@ pub static WORD_IDENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_IDEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEND_CHILDREN),
+static WORD_IDEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ified"),
         dictgen::InsensitiveStr::Ascii("ifier"),
@@ -128461,12 +128461,12 @@ pub static WORD_IDEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_IDEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEM_CHILDREN),
+static WORD_IDEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("opotent"),
         dictgen::InsensitiveStr::Ascii("pontent"),
@@ -128475,23 +128475,23 @@ pub static WORD_IDEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_IDEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEL_CHILDREN),
+static WORD_IDEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEL_CHILDREN),
     value: Some(&["idle"]),
 };
 
-pub static WORD_IDEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ogy")],
     values: &[&["ideology"]],
     range: 3..=3,
 };
 
-static WORD_IDEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEI_CHILDREN),
+static WORD_IDEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntify"),
         dictgen::InsensitiveStr::Ascii("tifed"),
@@ -128500,23 +128500,23 @@ pub static WORD_IDEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_IDEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEF_CHILDREN),
+static WORD_IDEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inite")],
     values: &[&["indefinite"]],
     range: 5..=5,
 };
 
-static WORD_IDEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEA_CHILDREN),
+static WORD_IDEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("lisim"),
@@ -128544,12 +128544,12 @@ pub static WORD_IDEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_IDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDA_CHILDREN),
+static WORD_IDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eidae"),
@@ -128559,12 +128559,12 @@ pub static WORD_IDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_IC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IC_CHILDREN),
+static WORD_IC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eforg"),
         dictgen::InsensitiveStr::Ascii("efrong"),
@@ -128616,12 +128616,12 @@ pub static WORD_IC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_IB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IB_CHILDREN),
+static WORD_IB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IB_CHILDREN),
     value: None,
 };
 
-pub static WORD_IB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ject"),
         dictgen::InsensitiveStr::Ascii("jects"),
@@ -128641,12 +128641,12 @@ pub static WORD_IB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_IA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IA_CHILDREN),
+static WORD_IA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mge"),
         dictgen::InsensitiveStr::Ascii("mges"),
@@ -128655,12 +128655,12 @@ pub static WORD_IA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_H_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_H_CHILDREN),
+static WORD_H_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_H_CHILDREN),
     value: None,
 };
 
-static WORD_H_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_H_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HA_NODE),
     None,
     None,
@@ -128689,12 +128689,12 @@ static WORD_H_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HY_CHILDREN),
+static WORD_HY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HY_CHILDREN),
     value: None,
 };
 
-static WORD_HY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HY_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_HYB_NODE),
     None,
@@ -128723,12 +128723,12 @@ static WORD_HY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HYS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYS_CHILDREN),
+static WORD_HYS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tarical"),
         dictgen::InsensitiveStr::Ascii("tarically"),
@@ -128758,12 +128758,12 @@ pub static WORD_HYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_HYR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYR_CHILDREN),
+static WORD_HYR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bids"),
         dictgen::InsensitiveStr::Ascii("dation"),
@@ -128774,12 +128774,12 @@ pub static WORD_HYR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_HYP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HYP_CHILDREN),
+static WORD_HYP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HYP_CHILDREN),
     value: None,
 };
 
-static WORD_HYP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HYP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HYPA_NODE),
     None,
     Some(&WORD_HYPC_NODE),
@@ -128808,12 +128808,12 @@ static WORD_HYP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HYPV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPV_CHILDREN),
+static WORD_HYPV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ervisor"),
         dictgen::InsensitiveStr::Ascii("ervisors"),
@@ -128829,12 +128829,12 @@ pub static WORD_HYPV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_HYPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPT_CHILDREN),
+static WORD_HYPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("othetical"),
@@ -128844,12 +128844,12 @@ pub static WORD_HYPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_HYPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPR_CHILDREN),
+static WORD_HYPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocisy"),
         dictgen::InsensitiveStr::Ascii("ocite"),
@@ -128859,12 +128859,12 @@ pub static WORD_HYPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_HYPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPO_CHILDREN),
+static WORD_HYPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("condriac"),
         dictgen::InsensitiveStr::Ascii("cracy"),
@@ -128964,34 +128964,34 @@ pub static WORD_HYPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_HYPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPN_CHILDREN),
+static WORD_HYPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oss")],
     values: &[&["hypnosis"]],
     range: 3..=3,
 };
 
-static WORD_HYPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPH_CHILDREN),
+static WORD_HYPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("otesis")],
     values: &[&["hypothesis"]],
     range: 6..=6,
 };
 
-static WORD_HYPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPE_CHILDREN),
+static WORD_HYPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nate"),
@@ -129057,23 +129057,23 @@ pub static WORD_HYPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_HYPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPC_CHILDREN),
+static WORD_HYPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orite")],
     values: &[&["hypocrite"]],
     range: 5..=5,
 };
 
-static WORD_HYPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPA_CHILDREN),
+static WORD_HYPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thetical"),
         dictgen::InsensitiveStr::Ascii("thetically"),
@@ -129082,12 +129082,12 @@ pub static WORD_HYPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_HYO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYO_CHILDREN),
+static WORD_HYO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pcrite"),
         dictgen::InsensitiveStr::Ascii("pthetical"),
@@ -129097,12 +129097,12 @@ pub static WORD_HYO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=11,
 };
 
-static WORD_HYJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYJ_CHILDREN),
+static WORD_HYJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("acking"),
@@ -129111,12 +129111,12 @@ pub static WORD_HYJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_HYG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYG_CHILDREN),
+static WORD_HYG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eine"),
         dictgen::InsensitiveStr::Ascii("ene"),
@@ -129136,12 +129136,12 @@ pub static WORD_HYG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_HYE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYE_CHILDREN),
+static WORD_HYE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rarchy"),
         dictgen::InsensitiveStr::Ascii("rlink"),
@@ -129150,12 +129150,12 @@ pub static WORD_HYE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_HYD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYD_CHILDREN),
+static WORD_HYD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ogen"),
         dictgen::InsensitiveStr::Ascii("orgen"),
@@ -129187,12 +129187,12 @@ pub static WORD_HYD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_HYB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYB_CHILDREN),
+static WORD_HYB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYB_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernate"),
         dictgen::InsensitiveStr::Ascii("irds"),
@@ -129203,12 +129203,12 @@ pub static WORD_HYB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_HW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HW_CHILDREN),
+static WORD_HW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HW_CHILDREN),
     value: None,
 };
 
-pub static WORD_HW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("eaton"),
@@ -129228,12 +129228,12 @@ pub static WORD_HW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_HV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HV_CHILDREN),
+static WORD_HV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aing"),
@@ -129244,12 +129244,12 @@ pub static WORD_HV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_HU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HU_CHILDREN),
+static WORD_HU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HU_CHILDREN),
     value: None,
 };
 
-static WORD_HU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HUA_NODE),
     None,
     None,
@@ -129278,23 +129278,23 @@ static WORD_HU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUT_CHILDREN),
+static WORD_HUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nsman")],
     values: &[&["huntsman"]],
     range: 5..=5,
 };
 
-static WORD_HUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUS_CHILDREN),
+static WORD_HUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ban"),
         dictgen::InsensitiveStr::Ascii("bandos"),
@@ -129310,12 +129310,12 @@ pub static WORD_HUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_HUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUR_CHILDREN),
+static WORD_HUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dels"),
         dictgen::InsensitiveStr::Ascii("icane"),
@@ -129353,12 +129353,12 @@ pub static WORD_HUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_HUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUN_CHILDREN),
+static WORD_HUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agrian"),
         dictgen::InsensitiveStr::Ascii("agry"),
@@ -129398,12 +129398,12 @@ pub static WORD_HUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_HUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUM_CHILDREN),
+static WORD_HUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anaties"),
         dictgen::InsensitiveStr::Ascii("ands"),
@@ -129485,12 +129485,12 @@ pub static WORD_HUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_HUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUL_CHILDREN),
+static WORD_HUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("lucination"),
@@ -129500,23 +129500,23 @@ pub static WORD_HUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_HUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUE_CHILDREN),
+static WORD_HUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ristic")],
     values: &[&["heuristic"]],
     range: 6..=6,
 };
 
-static WORD_HUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUA_CHILDREN),
+static WORD_HUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nted"),
         dictgen::InsensitiveStr::Ascii("nting"),
@@ -129525,12 +129525,12 @@ pub static WORD_HUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_HT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HT_CHILDREN),
+static WORD_HT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acccess"),
         dictgen::InsensitiveStr::Ascii("acces"),
@@ -129582,12 +129582,12 @@ pub static WORD_HT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HS_CHILDREN),
+static WORD_HS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("eldon"),
@@ -129615,12 +129615,12 @@ pub static WORD_HS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_HR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HR_CHILDREN),
+static WORD_HR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adware"),
         dictgen::InsensitiveStr::Ascii("adwares"),
@@ -129646,23 +129646,23 @@ pub static WORD_HR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_HP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HP_CHILDREN),
+static WORD_HP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["hope"]],
     range: 1..=1,
 };
 
-static WORD_HO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HO_CHILDREN),
+static WORD_HO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HO_CHILDREN),
     value: None,
 };
 
-static WORD_HO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -129691,12 +129691,12 @@ static WORD_HO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOW_CHILDREN),
+static WORD_HOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eever"),
         dictgen::InsensitiveStr::Ascii("erver"),
@@ -129718,12 +129718,12 @@ pub static WORD_HOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_HOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOV_CHILDREN),
+static WORD_HOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ever"),
         dictgen::InsensitiveStr::Ascii("ewer"),
@@ -129732,12 +129732,12 @@ pub static WORD_HOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_HOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOU_CHILDREN),
+static WORD_HOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("nour"),
@@ -129767,12 +129767,12 @@ pub static WORD_HOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_HOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOT_CHILDREN),
+static WORD_HOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hsot"),
         dictgen::InsensitiveStr::Ascii("izontal"),
@@ -129796,12 +129796,12 @@ pub static WORD_HOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOS_CHILDREN),
+static WORD_HOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ited"),
         dictgen::InsensitiveStr::Ascii("itlity"),
@@ -129863,12 +129863,12 @@ pub static WORD_HOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOR_CHILDREN),
+static WORD_HOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ader"),
         dictgen::InsensitiveStr::Ascii("ading"),
@@ -129968,12 +129968,12 @@ pub static WORD_HOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_HOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOP_CHILDREN),
+static WORD_HOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efull"),
         dictgen::InsensitiveStr::Ascii("efulle"),
@@ -130027,12 +130027,12 @@ pub static WORD_HOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_HOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOO_CHILDREN),
+static WORD_HOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ok"),
         dictgen::InsensitiveStr::Ascii("oks"),
@@ -130042,12 +130042,12 @@ pub static WORD_HOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_HON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HON_CHILDREN),
+static WORD_HON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HON_CHILDREN),
     value: None,
 };
 
-pub static WORD_HON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eslty"),
         dictgen::InsensitiveStr::Ascii("eymon"),
@@ -130067,12 +130067,12 @@ pub static WORD_HON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_HOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HOM_CHILDREN),
+static WORD_HOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HOM_CHILDREN),
     value: Some(&["home"]),
 };
 
-static WORD_HOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HOM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HOMA_NODE),
     None,
     None,
@@ -130101,12 +130101,12 @@ static WORD_HOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HOMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOMO_CHILDREN),
+static WORD_HOMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egenous"),
         dictgen::InsensitiveStr::Ascii("epathy"),
@@ -130190,34 +130190,34 @@ pub static WORD_HOMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_HOMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOMN_CHILDREN),
+static WORD_HOMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iem")],
     values: &[&["hominem"]],
     range: 3..=3,
 };
 
-static WORD_HOML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOML_CHILDREN),
+static WORD_HOML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOML_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["homeless"]],
     range: 3..=3,
 };
 
-static WORD_HOMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOMI_CHILDREN),
+static WORD_HOMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("neim"),
         dictgen::InsensitiveStr::Ascii("neum"),
@@ -130226,12 +130226,12 @@ pub static WORD_HOMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_HOME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOME_CHILDREN),
+static WORD_HOME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOME_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("comeing"),
         dictgen::InsensitiveStr::Ascii("comming"),
@@ -130287,23 +130287,23 @@ pub static WORD_HOME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_HOMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOMA_CHILDREN),
+static WORD_HOMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("page")],
     values: &[&["homepage"]],
     range: 4..=4,
 };
 
-static WORD_HOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOL_CHILDREN),
+static WORD_HOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("diay"),
         dictgen::InsensitiveStr::Ascii("diays"),
@@ -130331,12 +130331,12 @@ pub static WORD_HOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOK_CHILDREN),
+static WORD_HOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("pins"),
@@ -130345,12 +130345,12 @@ pub static WORD_HOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_HOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOI_CHILDREN),
+static WORD_HOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lday"),
         dictgen::InsensitiveStr::Ascii("ldays"),
@@ -130359,12 +130359,12 @@ pub static WORD_HOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_HOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOE_CHILDREN),
+static WORD_HOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ks"),
         dictgen::InsensitiveStr::Ascii("mopathy"),
@@ -130384,12 +130384,12 @@ pub static WORD_HOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOD_CHILDREN),
+static WORD_HOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -130399,23 +130399,23 @@ pub static WORD_HOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_HN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HN_CHILDREN),
+static WORD_HN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("alder")],
     values: &[&["handler"]],
     range: 5..=5,
 };
 
-static WORD_HM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HM_CHILDREN),
+static WORD_HM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("di"),
         dictgen::InsensitiveStr::Ascii("tl"),
@@ -130424,34 +130424,34 @@ pub static WORD_HM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_HL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HL_CHILDREN),
+static WORD_HL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ep")],
     values: &[&["help"]],
     range: 2..=2,
 };
 
-static WORD_HJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HJ_CHILDREN),
+static WORD_HJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_HJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ave")],
     values: &[&["have"]],
     range: 3..=3,
 };
 
-static WORD_HI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HI_CHILDREN),
+static WORD_HI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HI_CHILDREN),
     value: None,
 };
 
-static WORD_HI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HIA_NODE),
     None,
     Some(&WORD_HIC_NODE),
@@ -130480,23 +130480,23 @@ static WORD_HI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIY_CHILDREN),
+static WORD_HIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("geine")],
     values: &[&["hygiene"]],
     range: 5..=5,
 };
 
-static WORD_HIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIT_CHILDREN),
+static WORD_HIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("boxers"),
         dictgen::InsensitiveStr::Ascii("boxs"),
@@ -130516,12 +130516,12 @@ pub static WORD_HIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_HIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIS_CHILDREN),
+static WORD_HIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("melf"),
         dictgen::InsensitiveStr::Ascii("ory"),
@@ -130623,12 +130623,12 @@ pub static WORD_HIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=15,
 };
 
-static WORD_HIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIR_CHILDREN),
+static WORD_HIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achy"),
         dictgen::InsensitiveStr::Ascii("archies"),
@@ -130650,12 +130650,12 @@ pub static WORD_HIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_HIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIP_CHILDREN),
+static WORD_HIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocritical"),
         dictgen::InsensitiveStr::Ascii("opotamus"),
@@ -130681,12 +130681,12 @@ pub static WORD_HIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_HIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIN_CHILDREN),
+static WORD_HIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("derance"),
         dictgen::InsensitiveStr::Ascii("derence"),
@@ -130714,12 +130714,12 @@ pub static WORD_HIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIM_CHILDREN),
+static WORD_HIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("selv"),
@@ -130729,12 +130729,12 @@ pub static WORD_HIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_HIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIL_CHILDREN),
+static WORD_HIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ight"),
         dictgen::InsensitiveStr::Ascii("ighted"),
@@ -130752,12 +130752,12 @@ pub static WORD_HIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_HIJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIJ_CHILDREN),
+static WORD_HIJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kack"),
         dictgen::InsensitiveStr::Ascii("kacked"),
@@ -130768,12 +130768,12 @@ pub static WORD_HIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_HIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIH_CHILDREN),
+static WORD_HIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("glight"),
@@ -130783,12 +130783,12 @@ pub static WORD_HIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIG_CHILDREN),
+static WORD_HIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eine"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -130908,12 +130908,12 @@ pub static WORD_HIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_HIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIE_CHILDREN),
+static WORD_HIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("archical"),
         dictgen::InsensitiveStr::Ascii("archies"),
@@ -130989,12 +130989,12 @@ pub static WORD_HIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_HID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HID_CHILDREN),
+static WORD_HID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HID_CHILDREN),
     value: None,
 };
 
-pub static WORD_HID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dden"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -131016,23 +131016,23 @@ pub static WORD_HID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_HIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIC_CHILDREN),
+static WORD_HIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["which"]],
     range: 1..=1,
 };
 
-static WORD_HIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIA_CHILDREN),
+static WORD_HIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rchical"),
         dictgen::InsensitiveStr::Ascii("rchically"),
@@ -131042,12 +131042,12 @@ pub static WORD_HIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HH_CHILDREN),
+static WORD_HH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ader"),
         dictgen::InsensitiveStr::Ascii("ttp"),
@@ -131056,23 +131056,23 @@ pub static WORD_HH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_HG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HG_CHILDREN),
+static WORD_HG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["he"]],
     range: 1..=1,
 };
 
-static WORD_HE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HE_CHILDREN),
+static WORD_HE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HE_CHILDREN),
     value: None,
 };
 
-static WORD_HE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HEA_NODE),
     None,
     None,
@@ -131101,12 +131101,12 @@ static WORD_HE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEX_CHILDREN),
+static WORD_HEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adeciaml"),
         dictgen::InsensitiveStr::Ascii("adeimcal"),
@@ -131132,12 +131132,12 @@ pub static WORD_HEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEV_CHILDREN),
+static WORD_HEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eanly"),
@@ -131147,12 +131147,12 @@ pub static WORD_HEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_HEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEU_CHILDREN),
+static WORD_HEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ristc"),
         dictgen::InsensitiveStr::Ascii("ristcs"),
@@ -131168,12 +131168,12 @@ pub static WORD_HEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_HET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HET_CHILDREN),
+static WORD_HET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HET_CHILDREN),
     value: None,
 };
 
-pub static WORD_HET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eresexual"),
         dictgen::InsensitiveStr::Ascii("erosexal"),
@@ -131193,12 +131193,12 @@ pub static WORD_HET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=11,
 };
 
-static WORD_HES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HES_CHILDREN),
+static WORD_HES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HES_CHILDREN),
     value: None,
 };
 
-pub static WORD_HES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -131238,12 +131238,12 @@ pub static WORD_HES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_HER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HER_CHILDREN),
+static WORD_HER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HER_CHILDREN),
     value: None,
 };
 
-pub static WORD_HER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("archy"),
@@ -131325,12 +131325,12 @@ pub static WORD_HER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_HEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEP_CHILDREN),
+static WORD_HEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ler"),
@@ -131340,12 +131340,12 @@ pub static WORD_HEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_HEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEO_CHILDREN),
+static WORD_HEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rics"),
         dictgen::InsensitiveStr::Ascii("rine"),
@@ -131354,12 +131354,12 @@ pub static WORD_HEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_HEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEN_CHILDREN),
+static WORD_HEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("derence"),
@@ -131377,12 +131377,12 @@ pub static WORD_HEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEM_CHILDREN),
+static WORD_HEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icircles"),
         dictgen::InsensitiveStr::Ascii("ingwary"),
@@ -131430,12 +131430,12 @@ pub static WORD_HEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEL_CHILDREN),
+static WORD_HEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEL_CHILDREN),
     value: Some(&["help", "hell", "heal"]),
 };
 
-pub static WORD_HEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ath"),
         dictgen::InsensitiveStr::Ascii("athcare"),
@@ -131511,12 +131511,12 @@ pub static WORD_HEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_HEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEI_CHILDREN),
+static WORD_HEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("delburg"),
         dictgen::InsensitiveStr::Ascii("gest"),
@@ -131574,34 +131574,34 @@ pub static WORD_HEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_HEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEG_CHILDREN),
+static WORD_HEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dehog")],
     values: &[&["hedgehog"]],
     range: 5..=5,
 };
 
-static WORD_HEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEF_CHILDREN),
+static WORD_HEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["heifer"]],
     range: 2..=2,
 };
 
-static WORD_HED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HED_CHILDREN),
+static WORD_HED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HED_CHILDREN),
     value: None,
 };
 
-pub static WORD_HED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("aers"),
@@ -131625,12 +131625,12 @@ pub static WORD_HED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_HEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HEA_CHILDREN),
+static WORD_HEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HEA_CHILDREN),
     value: None,
 };
 
-static WORD_HEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HEA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_HEAC_NODE),
@@ -131659,12 +131659,12 @@ static WORD_HEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HEAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAV_CHILDREN),
+static WORD_HEAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ely"),
         dictgen::InsensitiveStr::Ascii("eny"),
@@ -131694,12 +131694,12 @@ pub static WORD_HEAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_HEAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAT_CHILDREN),
+static WORD_HEAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hern"),
         dictgen::InsensitiveStr::Ascii("hy"),
@@ -131710,23 +131710,23 @@ pub static WORD_HEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_HEAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAS_CHILDREN),
+static WORD_HEAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tink")],
     values: &[&["heatsink"]],
     range: 4..=4,
 };
 
-static WORD_HEAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAR_CHILDREN),
+static WORD_HEAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("beat"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -131760,12 +131760,12 @@ pub static WORD_HEAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_HEAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAP_CHILDREN),
+static WORD_HEAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dhone"),
         dictgen::InsensitiveStr::Ascii("dhones"),
@@ -131774,12 +131774,12 @@ pub static WORD_HEAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_HEAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAL_CHILDREN),
+static WORD_HEAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ither"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -131813,23 +131813,23 @@ pub static WORD_HEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_HEAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAE_CHILDREN),
+static WORD_HEAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["header"]],
     range: 1..=1,
 };
 
-static WORD_HEAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAD_CHILDREN),
+static WORD_HEAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achs"),
         dictgen::InsensitiveStr::Ascii("ahces"),
@@ -131893,23 +131893,23 @@ pub static WORD_HEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_HEAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAC_CHILDREN),
+static WORD_HEAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["heavy"]],
     range: 1..=1,
 };
 
-static WORD_HD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HD_CHILDREN),
+static WORD_HD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("insight"),
@@ -131918,12 +131918,12 @@ pub static WORD_HD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HA_CHILDREN),
+static WORD_HA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HA_CHILDREN),
     value: None,
 };
 
-static WORD_HA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HAA_NODE),
     Some(&WORD_HAB_NODE),
     Some(&WORD_HAC_NODE),
@@ -131952,45 +131952,45 @@ static WORD_HA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_HAZ_NODE),
 ];
 
-static WORD_HAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAZ_CHILDREN),
+static WORD_HAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("zle")],
     values: &[&["hassle"]],
     range: 3..=3,
 };
 
-static WORD_HAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAY_CHILDREN),
+static WORD_HAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nus")],
     values: &[&["heinous"]],
     range: 3..=3,
 };
 
-static WORD_HAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAX_CHILDREN),
+static WORD_HAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAX_CHILDREN),
     value: Some(&["hex"]),
 };
 
-pub static WORD_HAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_HAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAV_CHILDREN),
+static WORD_HAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAV_CHILDREN),
     value: Some(&["have", "half"]),
 };
 
-pub static WORD_HAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ea"),
@@ -132024,12 +132024,12 @@ pub static WORD_HAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAU_CHILDREN),
+static WORD_HAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lted"),
         dictgen::InsensitiveStr::Ascii("ntig"),
@@ -132039,12 +132039,12 @@ pub static WORD_HAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_HAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAT_CHILDREN),
+static WORD_HAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chig"),
         dictgen::InsensitiveStr::Ascii("chign"),
@@ -132062,12 +132062,12 @@ pub static WORD_HAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_HAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAS_CHILDREN),
+static WORD_HAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("hi"),
@@ -132097,12 +132097,12 @@ pub static WORD_HAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_HAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAR_CHILDREN),
+static WORD_HAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ased"),
         dictgen::InsensitiveStr::Ascii("ases"),
@@ -132210,12 +132210,12 @@ pub static WORD_HAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_HAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAP_CHILDREN),
+static WORD_HAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("end"),
@@ -132301,12 +132301,12 @@ pub static WORD_HAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_HAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAO_CHILDREN),
+static WORD_HAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rder"),
         dictgen::InsensitiveStr::Ascii("rding"),
@@ -132315,12 +132315,12 @@ pub static WORD_HAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_HAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HAN_CHILDREN),
+static WORD_HAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HAN_CHILDREN),
     value: None,
 };
 
-static WORD_HAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -132349,23 +132349,23 @@ static WORD_HAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HANU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANU_CHILDREN),
+static WORD_HANU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANU_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["haunted"]],
     range: 3..=3,
 };
 
-static WORD_HANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANS_CHILDREN),
+static WORD_HANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hake"),
         dictgen::InsensitiveStr::Ascii("haked"),
@@ -132381,12 +132381,12 @@ pub static WORD_HANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_HANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANN_CHILDREN),
+static WORD_HANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bial"),
         dictgen::InsensitiveStr::Ascii("dle"),
@@ -132397,12 +132397,12 @@ pub static WORD_HANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_HANL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANL_CHILDREN),
+static WORD_HANL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -132432,12 +132432,12 @@ pub static WORD_HANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_HANK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANK_CHILDREN),
+static WORD_HANK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANK_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erchif"),
         dictgen::InsensitiveStr::Ascii("erchifs"),
@@ -132446,45 +132446,45 @@ pub static WORD_HANK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_HANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANI_CHILDREN),
+static WORD_HANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dcapped")],
     values: &[&["handicapped"]],
     range: 7..=7,
 };
 
-static WORD_HANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANG_CHILDREN),
+static WORD_HANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ig")],
     values: &[&["hanging"]],
     range: 2..=2,
 };
 
-static WORD_HANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANE_CHILDREN),
+static WORD_HANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["handle"]],
     range: 1..=1,
 };
 
-static WORD_HAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HAND_CHILDREN),
+static WORD_HAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HAND_CHILDREN),
     value: None,
 };
 
-static WORD_HAND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HAND_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_HANDB_NODE),
     Some(&WORD_HANDC_NODE),
@@ -132513,23 +132513,23 @@ static WORD_HAND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HANDY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDY_CHILDREN),
+static WORD_HANDY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDY_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("capped")],
     values: &[&["handicapped"]],
     range: 6..=6,
 };
 
-static WORD_HANDW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDW_CHILDREN),
+static WORD_HANDW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDW_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irting"),
         dictgen::InsensitiveStr::Ascii("riten"),
@@ -132545,12 +132545,12 @@ pub static WORD_HANDW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_HANDS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDS_CHILDREN),
+static WORD_HANDS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ake"),
         dictgen::InsensitiveStr::Ascii("hacke"),
@@ -132612,23 +132612,23 @@ pub static WORD_HANDS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_HANDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDR_CHILDREN),
+static WORD_HANDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("witing")],
     values: &[&["handwriting"]],
     range: 6..=6,
 };
 
-static WORD_HANDL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDL_CHILDREN),
+static WORD_HANDL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("are"),
@@ -132654,12 +132654,12 @@ pub static WORD_HANDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_HANDK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDK_CHILDREN),
+static WORD_HANDK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDK_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erchif"),
@@ -132669,12 +132669,12 @@ pub static WORD_HANDK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_HANDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDI_CHILDREN),
+static WORD_HANDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cape"),
         dictgen::InsensitiveStr::Ascii("caped"),
@@ -132683,34 +132683,34 @@ pub static WORD_HANDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_HANDH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDH_CHILDREN),
+static WORD_HANDH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ake")],
     values: &[&["handshake"]],
     range: 3..=3,
 };
 
-static WORD_HANDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDF_CHILDREN),
+static WORD_HANDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ull")],
     values: &[&["handful"]],
     range: 3..=3,
 };
 
-static WORD_HANDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDE_CHILDREN),
+static WORD_HANDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDE_CHILDREN),
     value: Some(&["handle", "hand"]),
 };
 
-pub static WORD_HANDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dley"),
         dictgen::InsensitiveStr::Ascii("dlly"),
@@ -132748,12 +132748,12 @@ pub static WORD_HANDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_HANDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDC_CHILDREN),
+static WORD_HANDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uffes"),
         dictgen::InsensitiveStr::Ascii("ufs"),
@@ -132762,12 +132762,12 @@ pub static WORD_HANDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_HANDB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDB_CHILDREN),
+static WORD_HANDB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDB_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ok"),
         dictgen::InsensitiveStr::Ascii("oook"),
@@ -132776,12 +132776,12 @@ pub static WORD_HANDB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_HAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAM_CHILDREN),
+static WORD_HAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bergers"),
         dictgen::InsensitiveStr::Ascii("bruger"),
@@ -132825,12 +132825,12 @@ pub static WORD_HAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_HAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAL_CHILDREN),
+static WORD_HAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arious"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -132902,12 +132902,12 @@ pub static WORD_HAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_HAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAI_CHILDREN),
+static WORD_HAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfax"),
         dictgen::InsensitiveStr::Ascii("rcuit"),
@@ -132918,23 +132918,23 @@ pub static WORD_HAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_HAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAH_CHILDREN),
+static WORD_HAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ve")],
     values: &[&["have", "halve", "half"]],
     range: 2..=2,
 };
 
-static WORD_HAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAG_CHILDREN),
+static WORD_HAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("ases"),
@@ -132944,23 +132944,23 @@ pub static WORD_HAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_HAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAF_CHILDREN),
+static WORD_HAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ltime")],
     values: &[&["halftime"]],
     range: 5..=5,
 };
 
-static WORD_HAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAE_CHILDREN),
+static WORD_HAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAE_CHILDREN),
     value: Some(&["have"]),
 };
 
-pub static WORD_HAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("morrage"),
@@ -132976,12 +132976,12 @@ pub static WORD_HAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAD_CHILDREN),
+static WORD_HAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("ler"),
@@ -132999,12 +132999,12 @@ pub static WORD_HAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_HAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAC_CHILDREN),
+static WORD_HAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -133020,12 +133020,12 @@ pub static WORD_HAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_HAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAB_CHILDREN),
+static WORD_HAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeus"),
         dictgen::InsensitiveStr::Ascii("bit"),
@@ -133047,23 +133047,23 @@ pub static WORD_HAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_HAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAA_CHILDREN),
+static WORD_HAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAA_CHILDREN),
     value: Some(&["has"]),
 };
 
-pub static WORD_HAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ve")],
     values: &[&["have"]],
     range: 2..=2,
 };
 
-static WORD_G_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_G_CHILDREN),
+static WORD_G_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_G_CHILDREN),
     value: None,
 };
 
-static WORD_G_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_G_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GA_NODE),
     None,
     None,
@@ -133092,12 +133092,12 @@ static WORD_G_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_GZ_NODE),
 ];
 
-static WORD_GZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GZ_CHILDREN),
+static WORD_GZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_GZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iniflate"),
         dictgen::InsensitiveStr::Ascii("iped"),
@@ -133106,12 +133106,12 @@ pub static WORD_GZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_GY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GY_CHILDREN),
+static WORD_GY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GY_CHILDREN),
     value: None,
 };
 
-pub static WORD_GY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lph"),
         dictgen::InsensitiveStr::Ascii("manstics"),
@@ -133139,23 +133139,23 @@ pub static WORD_GY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_GW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GW_CHILDREN),
+static WORD_GW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GW_CHILDREN),
     value: None,
 };
 
-pub static WORD_GW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ava")],
     values: &[&["guava"]],
     range: 3..=3,
 };
 
-static WORD_GU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GU_CHILDREN),
+static WORD_GU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GU_CHILDREN),
     value: None,
 };
 
-static WORD_GU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GUA_NODE),
     Some(&WORD_GUB_NODE),
     None,
@@ -133184,12 +133184,12 @@ static WORD_GU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GUY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUY_CHILDREN),
+static WORD_GUY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUY_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ser"),
         dictgen::InsensitiveStr::Ascii("sers"),
@@ -133200,12 +133200,12 @@ pub static WORD_GUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_GUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUT_CHILDREN),
+static WORD_GUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iarist"),
         dictgen::InsensitiveStr::Ascii("iars"),
@@ -133216,12 +133216,12 @@ pub static WORD_GUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_GUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUR_CHILDREN),
+static WORD_GUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adian"),
         dictgen::InsensitiveStr::Ascii("adians"),
@@ -133249,12 +133249,12 @@ pub static WORD_GUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_GUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUN_CHILDREN),
+static WORD_GUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anine"),
         dictgen::InsensitiveStr::Ascii("atanamo"),
@@ -133284,12 +133284,12 @@ pub static WORD_GUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=12,
 };
 
-static WORD_GUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUL_CHILDREN),
+static WORD_GUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lbile"),
         dictgen::InsensitiveStr::Ascii("libe"),
@@ -133298,12 +133298,12 @@ pub static WORD_GUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_GUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUI_CHILDREN),
+static WORD_GUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deance"),
         dictgen::InsensitiveStr::Ascii("deded"),
@@ -133335,12 +133335,12 @@ pub static WORD_GUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_GUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUE_CHILDREN),
+static WORD_GUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rrila"),
         dictgen::InsensitiveStr::Ascii("rrilas"),
@@ -133362,34 +133362,34 @@ pub static WORD_GUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_GUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUD_CHILDREN),
+static WORD_GUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUD_CHILDREN),
     value: Some(&["good"]),
 };
 
-pub static WORD_GUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["guide", "good"]],
     range: 1..=1,
 };
 
-static WORD_GUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUB_CHILDREN),
+static WORD_GUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("natorial")],
     values: &[&["gubernatorial"]],
     range: 8..=8,
 };
 
-static WORD_GUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GUA_CHILDREN),
+static WORD_GUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GUA_CHILDREN),
     value: None,
 };
 
-static WORD_GUA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GUA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -133418,12 +133418,12 @@ static WORD_GUA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GUAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAT_CHILDREN),
+static WORD_GUAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amala"),
         dictgen::InsensitiveStr::Ascii("amalan"),
@@ -133432,12 +133432,12 @@ pub static WORD_GUAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_GUAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAS_CHILDREN),
+static WORD_GUAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAS_CHILDREN),
     value: Some(&["gauss"]),
 };
 
-pub static WORD_GUAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("sian"),
@@ -133446,12 +133446,12 @@ pub static WORD_GUAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_GUAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GUAR_CHILDREN),
+static WORD_GUAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GUAR_CHILDREN),
     value: None,
 };
 
-static WORD_GUAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GUAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GUARA_NODE),
     Some(&WORD_GUARB_NODE),
     None,
@@ -133480,12 +133480,12 @@ static WORD_GUAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GUARU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARU_CHILDREN),
+static WORD_GUARU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ante"),
         dictgen::InsensitiveStr::Ascii("anted"),
@@ -133529,23 +133529,23 @@ pub static WORD_GUARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_GUART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUART_CHILDREN),
+static WORD_GUART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUART_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eed")],
     values: &[&["guaranteed"]],
     range: 3..=3,
 };
 
-static WORD_GUARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARR_CHILDREN),
+static WORD_GUARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ante"),
         dictgen::InsensitiveStr::Ascii("anted"),
@@ -133603,12 +133603,12 @@ pub static WORD_GUARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_GUARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARN_CHILDREN),
+static WORD_GUARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ante"),
         dictgen::InsensitiveStr::Ascii("anted"),
@@ -133698,12 +133698,12 @@ pub static WORD_GUARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_GUARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARI_CHILDREN),
+static WORD_GUARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dan"),
         dictgen::InsensitiveStr::Ascii("dans"),
@@ -133712,23 +133712,23 @@ pub static WORD_GUARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_GUARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARG_CHILDREN),
+static WORD_GUARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["guarding"]],
     range: 3..=3,
 };
 
-static WORD_GUARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARE_CHILDREN),
+static WORD_GUARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -133810,12 +133810,12 @@ pub static WORD_GUARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_GUARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARD_CHILDREN),
+static WORD_GUARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ains"),
@@ -133837,23 +133837,23 @@ pub static WORD_GUARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_GUARB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARB_CHILDREN),
+static WORD_GUARB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["garbage"]],
     range: 3..=3,
 };
 
-static WORD_GUARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARA_CHILDREN),
+static WORD_GUARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nte"),
         dictgen::InsensitiveStr::Ascii("nted"),
@@ -133881,12 +133881,12 @@ pub static WORD_GUARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_GUAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAN_CHILDREN),
+static WORD_GUAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atanmo"),
         dictgen::InsensitiveStr::Ascii("tamamo"),
@@ -133916,23 +133916,23 @@ pub static WORD_GUAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_GUAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAG_CHILDREN),
+static WORD_GUAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["gage"]],
     range: 1..=1,
 };
 
-static WORD_GUAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAD_CHILDREN),
+static WORD_GUAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uloupe"),
         dictgen::InsensitiveStr::Ascii("ulupe"),
@@ -133941,23 +133941,23 @@ pub static WORD_GUAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_GT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GT_CHILDREN),
+static WORD_GT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("he")],
     values: &[&["the"]],
     range: 2..=2,
 };
 
-static WORD_GR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GR_CHILDREN),
+static WORD_GR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GR_CHILDREN),
     value: None,
 };
 
-static WORD_GR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GRA_NODE),
     Some(&WORD_GRB_NODE),
     None,
@@ -133986,23 +133986,23 @@ static WORD_GR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRW_CHILDREN),
+static WORD_GRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("o")],
     values: &[&["grow"]],
     range: 1..=1,
 };
 
-static WORD_GRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRU_CHILDREN),
+static WORD_GRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("op"),
         dictgen::InsensitiveStr::Ascii("opd"),
@@ -134026,23 +134026,23 @@ pub static WORD_GRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_GRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRR_CHILDREN),
+static WORD_GRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("anted")],
     values: &[&["granted"]],
     range: 5..=5,
 };
 
-static WORD_GRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRP_CHILDREN),
+static WORD_GRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ah"),
         dictgen::InsensitiveStr::Ascii("ahic"),
@@ -134062,12 +134062,12 @@ pub static WORD_GRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_GRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRO_CHILDREN),
+static WORD_GRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bal"),
         dictgen::InsensitiveStr::Ascii("bally"),
@@ -134135,12 +134135,12 @@ pub static WORD_GRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_GRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRI_CHILDREN),
+static WORD_GRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("affe"),
         dictgen::InsensitiveStr::Ascii("dles"),
@@ -134172,12 +134172,12 @@ pub static WORD_GRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_GRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRE_CHILDREN),
+static WORD_GRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ande"),
@@ -134235,23 +134235,23 @@ pub static WORD_GRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_GRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRB_CHILDREN),
+static WORD_GRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ber")],
     values: &[&["grabber"]],
     range: 3..=3,
 };
 
-static WORD_GRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GRA_CHILDREN),
+static WORD_GRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GRA_CHILDREN),
     value: None,
 };
 
-static WORD_GRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_GRAB_NODE),
     Some(&WORD_GRAC_NODE),
@@ -134280,12 +134280,12 @@ static WORD_GRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAV_CHILDREN),
+static WORD_GRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itacional"),
         dictgen::InsensitiveStr::Ascii("itaitonal"),
@@ -134305,12 +134305,12 @@ pub static WORD_GRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=10,
 };
 
-static WORD_GRAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAU_CHILDREN),
+static WORD_GRAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dally"),
         dictgen::InsensitiveStr::Ascii("dates"),
@@ -134326,12 +134326,12 @@ pub static WORD_GRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_GRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAT_CHILDREN),
+static WORD_GRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAT_CHILDREN),
     value: Some(&["great"]),
 };
 
-pub static WORD_GRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efull"),
         dictgen::InsensitiveStr::Ascii("ful"),
@@ -134369,12 +134369,12 @@ pub static WORD_GRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_GRAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAS_CHILDREN),
+static WORD_GRAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("srooots"),
         dictgen::InsensitiveStr::Ascii("srooters"),
@@ -134383,12 +134383,12 @@ pub static WORD_GRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_GRAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAP_CHILDREN),
+static WORD_GRAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efriut"),
         dictgen::InsensitiveStr::Ascii("efrukt"),
@@ -134426,23 +134426,23 @@ pub static WORD_GRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_GRAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAO_CHILDREN),
+static WORD_GRAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["graph"]],
     range: 1..=1,
 };
 
-static WORD_GRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAN_CHILDREN),
+static WORD_GRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("children"),
         dictgen::InsensitiveStr::Ascii("dchilden"),
@@ -134512,12 +134512,12 @@ pub static WORD_GRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_GRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAM_CHILDREN),
+static WORD_GRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("atical"),
@@ -134551,12 +134551,12 @@ pub static WORD_GRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_GRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAI_CHILDREN),
+static WORD_GRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dent"),
         dictgen::InsensitiveStr::Ascii("dents"),
@@ -134574,12 +134574,12 @@ pub static WORD_GRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_GRAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAH_CHILDREN),
+static WORD_GRAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -134603,12 +134603,12 @@ pub static WORD_GRAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_GRAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAF_CHILDREN),
+static WORD_GRAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ics"),
         dictgen::InsensitiveStr::Ascii("ield"),
@@ -134618,23 +134618,23 @@ pub static WORD_GRAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_GRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAE_CHILDREN),
+static WORD_GRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["great"]],
     range: 1..=1,
 };
 
-static WORD_GRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAD_CHILDREN),
+static WORD_GRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aully"),
         dictgen::InsensitiveStr::Ascii("iant"),
@@ -134664,12 +134664,12 @@ pub static WORD_GRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_GRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAC_CHILDREN),
+static WORD_GRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efull"),
         dictgen::InsensitiveStr::Ascii("efullly"),
@@ -134687,12 +134687,12 @@ pub static WORD_GRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_GRAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAB_CHILDREN),
+static WORD_GRAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -134703,23 +134703,23 @@ pub static WORD_GRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_GP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GP_CHILDREN),
+static WORD_GP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GP_CHILDREN),
     value: None,
 };
 
-pub static WORD_GP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ysies")],
     values: &[&["gypsies"]],
     range: 5..=5,
 };
 
-static WORD_GO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GO_CHILDREN),
+static WORD_GO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GO_CHILDREN),
     value: None,
 };
 
-static WORD_GO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GOA_NODE),
     Some(&WORD_GOB_NODE),
     Some(&WORD_GOC_NODE),
@@ -134748,12 +134748,12 @@ static WORD_GO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOV_CHILDREN),
+static WORD_GOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("emrent"),
@@ -134845,12 +134845,12 @@ pub static WORD_GOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_GOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOU_CHILDREN),
+static WORD_GOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("ped"),
@@ -134870,12 +134870,12 @@ pub static WORD_GOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_GOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOT_CHILDREN),
+static WORD_GOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ee"),
         dictgen::InsensitiveStr::Ascii("ees"),
@@ -134886,12 +134886,12 @@ pub static WORD_GOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_GOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOS_CHILDREN),
+static WORD_GOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("epls"),
         dictgen::InsensitiveStr::Ascii("pells"),
@@ -134902,12 +134902,12 @@ pub static WORD_GOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_GOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOR_CHILDREN),
+static WORD_GOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("egous"),
@@ -134953,12 +134953,12 @@ pub static WORD_GOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_GOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOO_CHILDREN),
+static WORD_GOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dlcuk"),
         dictgen::InsensitiveStr::Ascii("dluk"),
@@ -134984,12 +134984,12 @@ pub static WORD_GOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_GON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GON_CHILDREN),
+static WORD_GON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GON_CHILDREN),
     value: None,
 };
 
-pub static WORD_GON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ewidl"),
         dictgen::InsensitiveStr::Ascii("gratulations"),
@@ -134999,12 +134999,12 @@ pub static WORD_GON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_GOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOL_CHILDREN),
+static WORD_GOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aith"),
         dictgen::InsensitiveStr::Ascii("akeeper"),
@@ -135038,12 +135038,12 @@ pub static WORD_GOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_GOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOI_CHILDREN),
+static WORD_GOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gn"),
@@ -135063,12 +135063,12 @@ pub static WORD_GOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_GOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOG_CHILDREN),
+static WORD_GOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ether"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -135077,12 +135077,12 @@ pub static WORD_GOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_GOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOE_CHILDREN),
+static WORD_GOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("graphic"),
         dictgen::InsensitiveStr::Ascii("graphical"),
@@ -135104,12 +135104,12 @@ pub static WORD_GOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_GOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOD_CHILDREN),
+static WORD_GOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("afther"),
         dictgen::InsensitiveStr::Ascii("dammn"),
@@ -135149,23 +135149,23 @@ pub static WORD_GOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_GOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOC_CHILDREN),
+static WORD_GOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("de")],
     values: &[&["gcode"]],
     range: 2..=2,
 };
 
-static WORD_GOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOB_CHILDREN),
+static WORD_GOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("lings"),
@@ -135174,12 +135174,12 @@ pub static WORD_GOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_GOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOA_CHILDREN),
+static WORD_GOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lkeaper"),
         dictgen::InsensitiveStr::Ascii("lkeepr"),
@@ -135195,12 +135195,12 @@ pub static WORD_GOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_GN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GN_CHILDREN),
+static WORD_GN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aking"),
         dictgen::InsensitiveStr::Ascii("awwed"),
@@ -135236,23 +135236,23 @@ pub static WORD_GN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_GM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GM_CHILDREN),
+static WORD_GM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GM_CHILDREN),
     value: None,
 };
 
-pub static WORD_GM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aertag")],
     values: &[&["gamertag"]],
     range: 6..=6,
 };
 
-static WORD_GL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GL_CHILDREN),
+static WORD_GL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adiatr"),
         dictgen::InsensitiveStr::Ascii("agsow"),
@@ -135368,12 +135368,12 @@ pub static WORD_GL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_GI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GI_CHILDREN),
+static WORD_GI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agbyte"),
         dictgen::InsensitiveStr::Ascii("en"),
@@ -135485,12 +135485,12 @@ pub static WORD_GI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_GH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GH_CHILDREN),
+static WORD_GH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GH_CHILDREN),
     value: None,
 };
 
-pub static WORD_GH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andi"),
         dictgen::InsensitiveStr::Ascii("ostcript"),
@@ -135508,12 +135508,12 @@ pub static WORD_GH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_GG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GG_CHILDREN),
+static WORD_GG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("od"),
         dictgen::InsensitiveStr::Ascii("ogle"),
@@ -135529,12 +135529,12 @@ pub static WORD_GG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_GE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GE_CHILDREN),
+static WORD_GE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GE_CHILDREN),
     value: None,
 };
 
-static WORD_GE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -135563,23 +135563,23 @@ static WORD_GE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GEU_CHILDREN),
+static WORD_GEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rrilla")],
     values: &[&["guerrilla"]],
     range: 6..=6,
 };
 
-static WORD_GET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GET_CHILDREN),
+static WORD_GET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GET_CHILDREN),
     value: None,
 };
 
-pub static WORD_GET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egories"),
         dictgen::InsensitiveStr::Ascii("fastproperyvalue"),
@@ -135627,23 +135627,23 @@ pub static WORD_GET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=16,
 };
 
-static WORD_GES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GES_CHILDREN),
+static WORD_GES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GES_CHILDREN),
     value: None,
 };
 
-pub static WORD_GES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["guess"]],
     range: 1..=1,
 };
 
-static WORD_GER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GER_CHILDREN),
+static WORD_GER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GER_CHILDREN),
     value: None,
 };
 
-pub static WORD_GER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aff"),
         dictgen::InsensitiveStr::Ascii("aphics"),
@@ -135731,12 +135731,12 @@ pub static WORD_GER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_GEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GEO_CHILDREN),
+static WORD_GEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("centic"),
         dictgen::InsensitiveStr::Ascii("emtries"),
@@ -135842,12 +135842,12 @@ pub static WORD_GEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_GEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GEN_CHILDREN),
+static WORD_GEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GEN_CHILDREN),
     value: None,
 };
 
-static WORD_GEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GENA_NODE),
     None,
     None,
@@ -135876,12 +135876,12 @@ static WORD_GEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GENU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENU_CHILDREN),
+static WORD_GENU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ienly"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -135901,12 +135901,12 @@ pub static WORD_GENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_GENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENT_CHILDREN),
+static WORD_GENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailia"),
         dictgen::InsensitiveStr::Ascii("al"),
@@ -135928,12 +135928,12 @@ pub static WORD_GENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_GENR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENR_CHILDREN),
+static WORD_GENR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alisation"),
@@ -135999,23 +135999,23 @@ pub static WORD_GENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_GENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENO_CHILDREN),
+static WORD_GENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mew")],
     values: &[&["genome"]],
     range: 3..=3,
 };
 
-static WORD_GENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENI_CHILDREN),
+static WORD_GENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alia"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -136047,12 +136047,12 @@ pub static WORD_GENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_GENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GENE_CHILDREN),
+static WORD_GENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GENE_CHILDREN),
     value: None,
 };
 
-static WORD_GENE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GENE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GENEA_NODE),
     None,
     None,
@@ -136081,12 +136081,12 @@ static WORD_GENE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GENET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENET_CHILDREN),
+static WORD_GENET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENET_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icaly"),
         dictgen::InsensitiveStr::Ascii("iclly"),
@@ -136096,12 +136096,12 @@ pub static WORD_GENET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_GENER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GENER_CHILDREN),
+static WORD_GENER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GENER_CHILDREN),
     value: None,
 };
 
-static WORD_GENER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GENER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GENERA_NODE),
     None,
     None,
@@ -136130,12 +136130,12 @@ static WORD_GENER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GENERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERT_CHILDREN),
+static WORD_GENERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -136155,23 +136155,23 @@ pub static WORD_GENERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_GENERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERS_CHILDREN),
+static WORD_GENERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["generals"]],
     range: 1..=1,
 };
 
-static WORD_GENERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERO_CHILDREN),
+static WORD_GENERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ator"),
         dictgen::InsensitiveStr::Ascii("city"),
@@ -136189,12 +136189,12 @@ pub static WORD_GENERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_GENERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERL_CHILDREN),
+static WORD_GENERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("aizes"),
@@ -136204,12 +136204,12 @@ pub static WORD_GENERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_GENERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERI_CHILDREN),
+static WORD_GENERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lise"),
         dictgen::InsensitiveStr::Ascii("lised"),
@@ -136231,12 +136231,12 @@ pub static WORD_GENERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_GENERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERE_CHILDREN),
+static WORD_GENERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -136282,12 +136282,12 @@ pub static WORD_GENERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_GENERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERA_CHILDREN),
+static WORD_GENERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("cional"),
@@ -136393,12 +136393,12 @@ pub static WORD_GENERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_GENEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENEO_CHILDREN),
+static WORD_GENEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logical"),
         dictgen::InsensitiveStr::Ascii("logies"),
@@ -136408,12 +136408,12 @@ pub static WORD_GENEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_GENEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENEN_CHILDREN),
+static WORD_GENEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erally"),
         dictgen::InsensitiveStr::Ascii("ric"),
@@ -136422,23 +136422,23 @@ pub static WORD_GENEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_GENEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENEI_CHILDREN),
+static WORD_GENEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("c")],
     values: &[&["generic", "genetic"]],
     range: 1..=1,
 };
 
-static WORD_GENEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENEA_CHILDREN),
+static WORD_GENEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ral"),
         dictgen::InsensitiveStr::Ascii("rally"),
@@ -136466,12 +136466,12 @@ pub static WORD_GENEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_GENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENA_CHILDREN),
+static WORD_GENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ral"),
         dictgen::InsensitiveStr::Ascii("rate"),
@@ -136493,12 +136493,12 @@ pub static WORD_GENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_GEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GEM_CHILDREN),
+static WORD_GEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_GEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etrical"),
         dictgen::InsensitiveStr::Ascii("etry"),
@@ -136514,12 +136514,12 @@ pub static WORD_GEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_GEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GEE_CHILDREN),
+static WORD_GEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("neric"),
         dictgen::InsensitiveStr::Ascii("nrate"),
@@ -136543,12 +136543,12 @@ pub static WORD_GEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_GA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GA_CHILDREN),
+static WORD_GA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GA_CHILDREN),
     value: None,
 };
 
-static WORD_GA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_GAB_NODE),
     None,
@@ -136577,12 +136577,12 @@ static WORD_GA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAY_CHILDREN),
+static WORD_GAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ity"),
         dictgen::InsensitiveStr::Ascii("sha"),
@@ -136592,12 +136592,12 @@ pub static WORD_GAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_GAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAU_CHILDREN),
+static WORD_GAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("arana"),
@@ -136659,12 +136659,12 @@ pub static WORD_GAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_GAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAT_CHILDREN),
+static WORD_GAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -136684,23 +136684,23 @@ pub static WORD_GAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_GAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAS_CHILDREN),
+static WORD_GAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tly")],
     values: &[&["ghastly", "vastly"]],
     range: 3..=3,
 };
 
-static WORD_GAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAR_CHILDREN),
+static WORD_GAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abge"),
         dictgen::InsensitiveStr::Ascii("antee"),
@@ -136782,12 +136782,12 @@ pub static WORD_GAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_GAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAN_CHILDREN),
+static WORD_GAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bia"),
         dictgen::InsensitiveStr::Ascii("erate"),
@@ -136815,12 +136815,12 @@ pub static WORD_GAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_GAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAM_CHILDREN),
+static WORD_GAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAM_CHILDREN),
     value: Some(&["game"]),
 };
 
-pub static WORD_GAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emdoe"),
         dictgen::InsensitiveStr::Ascii("epaly"),
@@ -136842,12 +136842,12 @@ pub static WORD_GAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_GAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAL_CHILDREN),
+static WORD_GAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atic"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -136881,23 +136881,23 @@ pub static WORD_GAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_GAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAI_CHILDREN),
+static WORD_GAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nined")],
     values: &[&["gained"]],
     range: 5..=5,
 };
 
-static WORD_GAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAG_CHILDREN),
+static WORD_GAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dets"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -136915,12 +136915,12 @@ pub static WORD_GAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_GAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAD_CHILDREN),
+static WORD_GAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ged"),
         dictgen::InsensitiveStr::Ascii("gest"),
@@ -136929,23 +136929,23 @@ pub static WORD_GAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_GAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAB_CHILDREN),
+static WORD_GAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["garbage"]],
     range: 3..=3,
 };
 
-static WORD_F_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_F_CHILDREN),
+static WORD_F_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_F_CHILDREN),
     value: None,
 };
 
-static WORD_F_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_F_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FA_NODE),
     None,
     Some(&WORD_FC_NODE),
@@ -136974,12 +136974,12 @@ static WORD_F_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FY_CHILDREN),
+static WORD_FY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FY_CHILDREN),
     value: None,
 };
 
-pub static WORD_FY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ou"),
         dictgen::InsensitiveStr::Ascii("sical"),
@@ -136990,23 +136990,23 @@ pub static WORD_FY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FX_CHILDREN),
+static WORD_FX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["fixed"]],
     range: 2..=2,
 };
 
-static WORD_FW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FW_CHILDREN),
+static WORD_FW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ankenstein"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -137016,12 +137016,12 @@ pub static WORD_FW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_FU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FU_CHILDREN),
+static WORD_FU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FU_CHILDREN),
     value: None,
 };
 
-static WORD_FU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FUA_NODE),
     Some(&WORD_FUB_NODE),
     Some(&WORD_FUC_NODE),
@@ -137050,12 +137050,12 @@ static WORD_FU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUT_CHILDREN),
+static WORD_FUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -137101,12 +137101,12 @@ pub static WORD_FUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUS_CHILDREN),
+static WORD_FUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chia"),
         dictgen::InsensitiveStr::Ascii("ha"),
@@ -137132,12 +137132,12 @@ pub static WORD_FUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_FUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUR_CHILDREN),
+static WORD_FUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ctose"),
@@ -137253,12 +137253,12 @@ pub static WORD_FUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FUN_CHILDREN),
+static WORD_FUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FUN_CHILDREN),
     value: None,
 };
 
-static WORD_FUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FUN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_FUNC_NODE),
@@ -137287,12 +137287,12 @@ static WORD_FUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FUNX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNX_CHILDREN),
+static WORD_FUNX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tional"),
@@ -137314,12 +137314,12 @@ pub static WORD_FUNX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_FUNV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNV_CHILDREN),
+static WORD_FUNV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNV_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -137343,12 +137343,12 @@ pub static WORD_FUNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_FUNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNT_CHILDREN),
+static WORD_FUNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -137376,12 +137376,12 @@ pub static WORD_FUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_FUNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNR_CHILDREN),
+static WORD_FUNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("els"),
@@ -137390,12 +137390,12 @@ pub static WORD_FUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_FUNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNN_CHILDREN),
+static WORD_FUNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iliy"),
         dictgen::InsensitiveStr::Ascii("illy"),
@@ -137405,23 +137405,23 @@ pub static WORD_FUNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_FUNK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNK_CHILDREN),
+static WORD_FUNK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNK_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["function"]],
     range: 4..=4,
 };
 
-static WORD_FUNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNI_CHILDREN),
+static WORD_FUNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("des"),
         dictgen::InsensitiveStr::Ascii("ture"),
@@ -137430,23 +137430,23 @@ pub static WORD_FUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_FUNG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNG_CHILDREN),
+static WORD_FUNG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uses")],
     values: &[&["fungi"]],
     range: 4..=4,
 };
 
-static WORD_FUND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUND_CHILDREN),
+static WORD_FUND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUND_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amendalist"),
         dictgen::InsensitiveStr::Ascii("amendalists"),
@@ -137548,12 +137548,12 @@ pub static WORD_FUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=14,
 };
 
-static WORD_FUNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FUNC_CHILDREN),
+static WORD_FUNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FUNC_CHILDREN),
     value: None,
 };
 
-static WORD_FUNC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FUNC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FUNCA_NODE),
     None,
     None,
@@ -137582,23 +137582,23 @@ static WORD_FUNC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_FUNCZ_NODE),
 ];
 
-static WORD_FUNCZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCZ_CHILDREN),
+static WORD_FUNCZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ion")],
     values: &[&["function"]],
     range: 3..=3,
 };
 
-static WORD_FUNCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCT_CHILDREN),
+static WORD_FUNCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iion"),
         dictgen::InsensitiveStr::Ascii("iional"),
@@ -137724,12 +137724,12 @@ pub static WORD_FUNCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_FUNCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCS_CHILDREN),
+static WORD_FUNCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ions"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -137739,12 +137739,12 @@ pub static WORD_FUNCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_FUNCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCI_CHILDREN),
+static WORD_FUNCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("onal"),
@@ -137780,12 +137780,12 @@ pub static WORD_FUNCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_FUNCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCH_CHILDREN),
+static WORD_FUNCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tional"),
@@ -137813,12 +137813,12 @@ pub static WORD_FUNCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_FUNCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCA_CHILDREN),
+static WORD_FUNCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tionality"),
@@ -137827,12 +137827,12 @@ pub static WORD_FUNCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_FUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUM_CHILDREN),
+static WORD_FUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -137850,12 +137850,12 @@ pub static WORD_FUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_FUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUL_CHILDREN),
+static WORD_FUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUL_CHILDREN),
     value: Some(&["full"]),
 };
 
-pub static WORD_FUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("filed"),
@@ -137919,12 +137919,12 @@ pub static WORD_FUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUG_CHILDREN),
+static WORD_FUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ure"),
         dictgen::InsensitiveStr::Ascii("ured"),
@@ -137934,12 +137934,12 @@ pub static WORD_FUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_FUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUF_CHILDREN),
+static WORD_FUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ill"),
         dictgen::InsensitiveStr::Ascii("illed"),
@@ -137949,12 +137949,12 @@ pub static WORD_FUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_FUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUE_CHILDREN),
+static WORD_FUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("therst"),
         dictgen::InsensitiveStr::Ascii("thest"),
@@ -137963,12 +137963,12 @@ pub static WORD_FUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_FUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUC_CHILDREN),
+static WORD_FUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntion"),
         dictgen::InsensitiveStr::Ascii("ntional"),
@@ -138002,23 +138002,23 @@ pub static WORD_FUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_FUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUB_CHILDREN),
+static WORD_FUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ding")],
     values: &[&["funding"]],
     range: 4..=4,
 };
 
-static WORD_FUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUA_CHILDREN),
+static WORD_FUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lt"),
         dictgen::InsensitiveStr::Ascii("lts"),
@@ -138027,12 +138027,12 @@ pub static WORD_FUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_FT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FT_CHILDREN),
+static WORD_FT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bs"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -138043,23 +138043,23 @@ pub static WORD_FT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_FS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FS_CHILDREN),
+static WORD_FS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("chk")],
     values: &[&["fsck"]],
     range: 3..=3,
 };
 
-static WORD_FR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FR_CHILDREN),
+static WORD_FR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FR_CHILDREN),
     value: None,
 };
 
-static WORD_FR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FRA_NODE),
     None,
     None,
@@ -138088,12 +138088,12 @@ static WORD_FR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRU_CHILDREN),
+static WORD_FRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adulent"),
         dictgen::InsensitiveStr::Ascii("itin"),
@@ -138151,12 +138151,12 @@ pub static WORD_FRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_FRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRS_CHILDREN),
+static WORD_FRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibee"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -138165,23 +138165,23 @@ pub static WORD_FRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_FRQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRQ_CHILDREN),
+static WORD_FRQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uency")],
     values: &[&["frequency"]],
     range: 5..=5,
 };
 
-static WORD_FRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRO_CHILDREN),
+static WORD_FRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("day"),
@@ -138285,12 +138285,12 @@ pub static WORD_FRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRM_CHILDREN),
+static WORD_FRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -138299,12 +138299,12 @@ pub static WORD_FRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_FRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRI_CHILDREN),
+static WORD_FRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cton"),
         dictgen::InsensitiveStr::Ascii("dey"),
@@ -138398,23 +138398,23 @@ pub static WORD_FRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_FRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRG_CHILDREN),
+static WORD_FRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ament")],
     values: &[&["fragment"]],
     range: 5..=5,
 };
 
-static WORD_FRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FRE_CHILDREN),
+static WORD_FRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FRE_CHILDREN),
     value: Some(&["free"]),
 };
 
-static WORD_FRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_FREC_NODE),
@@ -138443,12 +138443,12 @@ static WORD_FRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_FREZ_NODE),
 ];
 
-static WORD_FREZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREZ_CHILDREN),
+static WORD_FREZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -138457,23 +138457,23 @@ pub static WORD_FREZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_FRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRES_CHILDREN),
+static WORD_FRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hkly")],
     values: &[&["freshly"]],
     range: 4..=4,
 };
 
-static WORD_FREQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREQ_CHILDREN),
+static WORD_FREQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encies"),
         dictgen::InsensitiveStr::Ascii("ency"),
@@ -138537,12 +138537,12 @@ pub static WORD_FREQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_FREM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREM_CHILDREN),
+static WORD_FREM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entation"),
         dictgen::InsensitiveStr::Ascii("ented"),
@@ -138551,12 +138551,12 @@ pub static WORD_FREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_FREI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREI_CHILDREN),
+static WORD_FREI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ndlies"),
@@ -138578,12 +138578,12 @@ pub static WORD_FREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_FREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREE_CHILDREN),
+static WORD_FREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("callrelpy"),
         dictgen::InsensitiveStr::Ascii("deom"),
@@ -138623,12 +138623,12 @@ pub static WORD_FREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_FREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREC_CHILDREN),
+static WORD_FREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kels"),
         dictgen::InsensitiveStr::Ascii("klers"),
@@ -138652,12 +138652,12 @@ pub static WORD_FREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_FRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FRA_CHILDREN),
+static WORD_FRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FRA_CHILDREN),
     value: None,
 };
 
-static WORD_FRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_FRAC_NODE),
@@ -138686,12 +138686,12 @@ static WORD_FRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FRAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAU_CHILDREN),
+static WORD_FRAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dalent"),
         dictgen::InsensitiveStr::Ascii("delant"),
@@ -138709,12 +138709,12 @@ pub static WORD_FRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_FRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAT_CHILDREN),
+static WORD_FRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernaty"),
         dictgen::InsensitiveStr::Ascii("ernety"),
@@ -138732,12 +138732,12 @@ pub static WORD_FRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_FRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAN_CHILDREN),
+static WORD_FRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caises"),
         dictgen::InsensitiveStr::Ascii("ches"),
@@ -138807,12 +138807,12 @@ pub static WORD_FRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_FRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAM_CHILDREN),
+static WORD_FRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAM_CHILDREN),
     value: Some(&["frame"]),
 };
 
-pub static WORD_FRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("buffer"),
         dictgen::InsensitiveStr::Ascii("ebufer"),
@@ -138868,12 +138868,12 @@ pub static WORD_FRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_FRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAG_CHILDREN),
+static WORD_FRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ementation"),
@@ -138913,34 +138913,34 @@ pub static WORD_FRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_FRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAE_CHILDREN),
+static WORD_FRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("buffer")],
     values: &[&["framebuffer"]],
     range: 6..=6,
 };
 
-static WORD_FRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAD_CHILDREN),
+static WORD_FRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ulent")],
     values: &[&["fraudulent"]],
     range: 5..=5,
 };
 
-static WORD_FRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAC_CHILDREN),
+static WORD_FRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ional"),
         dictgen::InsensitiveStr::Ascii("kign"),
@@ -138970,12 +138970,12 @@ pub static WORD_FRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_FP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FP_CHILDREN),
+static WORD_FP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FP_CHILDREN),
     value: None,
 };
 
-pub static WORD_FP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -138986,12 +138986,12 @@ pub static WORD_FP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_FO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FO_CHILDREN),
+static WORD_FO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FO_CHILDREN),
     value: Some(&["of", "for", "do", "go", "to"]),
 };
 
-static WORD_FO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_FOC_NODE),
@@ -139020,12 +139020,12 @@ static WORD_FO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOW_CHILDREN),
+static WORD_FOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("arded"),
@@ -139047,12 +139047,12 @@ pub static WORD_FOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOU_CHILDREN),
+static WORD_FOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cs"),
         dictgen::InsensitiveStr::Ascii("csed"),
@@ -139112,12 +139112,12 @@ pub static WORD_FOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_FOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOT_CHILDREN),
+static WORD_FOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOT_CHILDREN),
     value: Some(&["for", "fit", "dot", "rot", "cot", "got", "tot", "fog"]),
 };
 
-pub static WORD_FOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("ograf"),
@@ -139139,12 +139139,12 @@ pub static WORD_FOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOS_CHILDREN),
+static WORD_FOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("siles"),
         dictgen::InsensitiveStr::Ascii("silis"),
@@ -139153,12 +139153,12 @@ pub static WORD_FOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_FOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FOR_CHILDREN),
+static WORD_FOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FOR_CHILDREN),
     value: None,
 };
 
-static WORD_FOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FORA_NODE),
     Some(&WORD_FORB_NODE),
     Some(&WORD_FORC_NODE),
@@ -139187,12 +139187,12 @@ static WORD_FOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FORW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORW_CHILDREN),
+static WORD_FORW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -139226,12 +139226,12 @@ pub static WORD_FORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_FORV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORV_CHILDREN),
+static WORD_FORV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORV_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atter"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -139240,12 +139240,12 @@ pub static WORD_FORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_FORU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORU_CHILDREN),
+static WORD_FORU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("la"),
         dictgen::InsensitiveStr::Ascii("las"),
@@ -139277,12 +139277,12 @@ pub static WORD_FORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_FORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORT_CHILDREN),
+static WORD_FORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -139332,12 +139332,12 @@ pub static WORD_FORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_FORS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORS_CHILDREN),
+static WORD_FORS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("akn"),
         dictgen::InsensitiveStr::Ascii("ane"),
@@ -139367,12 +139367,12 @@ pub static WORD_FORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORR_CHILDREN),
+static WORD_FORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORR_CHILDREN),
     value: Some(&["for"]),
 };
 
-pub static WORD_FORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esst"),
         dictgen::InsensitiveStr::Ascii("matter"),
@@ -139382,12 +139382,12 @@ pub static WORD_FORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_FORO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORO_CHILDREN),
+static WORD_FORO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tten"),
@@ -139396,12 +139396,12 @@ pub static WORD_FORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_FORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORN_CHILDREN),
+static WORD_FORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -139429,12 +139429,12 @@ pub static WORD_FORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FORM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORM_CHILDREN),
+static WORD_FORM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adible"),
         dictgen::InsensitiveStr::Ascii("alhaut"),
@@ -139568,12 +139568,12 @@ pub static WORD_FORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_FORL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORL_CHILDREN),
+static WORD_FORL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -139583,12 +139583,12 @@ pub static WORD_FORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_FORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORI_CHILDREN),
+static WORD_FORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cbly"),
         dictgen::InsensitiveStr::Ascii("egn"),
@@ -139616,23 +139616,23 @@ pub static WORD_FORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORH_CHILDREN),
+static WORD_FORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ead")],
     values: &[&["forehead"]],
     range: 3..=3,
 };
 
-static WORD_FORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORG_CHILDREN),
+static WORD_FORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ein"),
         dictgen::InsensitiveStr::Ascii("einer"),
@@ -139676,12 +139676,12 @@ pub static WORD_FORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_FORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORF_CHILDREN),
+static WORD_FORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iet"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -139699,12 +139699,12 @@ pub static WORD_FORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_FORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORE_CHILDREN),
+static WORD_FORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amrs"),
         dictgen::InsensitiveStr::Ascii("ard"),
@@ -139784,12 +139784,12 @@ pub static WORD_FORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_FORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORC_CHILDREN),
+static WORD_FORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("ast"),
@@ -139827,12 +139827,12 @@ pub static WORD_FORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_FORB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORB_CHILDREN),
+static WORD_FORB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("atum"),
@@ -139856,12 +139856,12 @@ pub static WORD_FORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_FORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORA_CHILDREN),
+static WORD_FORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matting"),
         dictgen::InsensitiveStr::Ascii("mt"),
@@ -139883,12 +139883,12 @@ pub static WORD_FORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_FOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOP_CHILDREN),
+static WORD_FOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("py"),
         dictgen::InsensitiveStr::Ascii("pys"),
@@ -139898,12 +139898,12 @@ pub static WORD_FOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_FOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOO_CHILDREN),
+static WORD_FOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntnotes"),
         dictgen::InsensitiveStr::Ascii("otball"),
@@ -139925,12 +139925,12 @@ pub static WORD_FOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_FON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FON_CHILDREN),
+static WORD_FON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FON_CHILDREN),
     value: None,
 };
 
-pub static WORD_FON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -139980,12 +139980,12 @@ pub static WORD_FON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_FOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOM_CHILDREN),
+static WORD_FOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOM_CHILDREN),
     value: Some(&["form", "from"]),
 };
 
-pub static WORD_FOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -140039,12 +140039,12 @@ pub static WORD_FOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_FOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FOL_CHILDREN),
+static WORD_FOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FOL_CHILDREN),
     value: None,
 };
 
-static WORD_FOL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FOL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -140073,23 +140073,23 @@ static WORD_FOL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FOLX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLX_CHILDREN),
+static WORD_FOLX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLX_CHILDREN),
     value: Some(&["folks"]),
 };
 
-pub static WORD_FOLX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FOLW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLW_CHILDREN),
+static WORD_FOLW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("oed"),
@@ -140121,23 +140121,23 @@ pub static WORD_FOLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FOLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLS_CHILDREN),
+static WORD_FOLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["false"]],
     range: 1..=1,
 };
 
-static WORD_FOLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLO_CHILDREN),
+static WORD_FOLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ow"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -140217,12 +140217,12 @@ pub static WORD_FOLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FOLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FOLL_CHILDREN),
+static WORD_FOLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FOLL_CHILDREN),
     value: None,
 };
 
-static WORD_FOLL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FOLL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -140251,12 +140251,12 @@ static WORD_FOLL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FOLLW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLW_CHILDREN),
+static WORD_FOLLW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLW_CHILDREN),
     value: Some(&["follow"]),
 };
 
-pub static WORD_FOLLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -140382,23 +140382,23 @@ pub static WORD_FOLLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FOLLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLS_CHILDREN),
+static WORD_FOLLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLS_CHILDREN),
     value: Some(&["follows"]),
 };
 
-pub static WORD_FOLLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FOLLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLO_CHILDREN),
+static WORD_FOLLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -140442,12 +140442,12 @@ pub static WORD_FOLLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FOLLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLL_CHILDREN),
+static WORD_FOLLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ow"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -140479,12 +140479,12 @@ pub static WORD_FOLLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_FOLLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLI_CHILDREN),
+static WORD_FOLLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nd"),
@@ -140528,12 +140528,12 @@ pub static WORD_FOLLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FOLLF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLF_CHILDREN),
+static WORD_FOLLF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ow"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -140565,12 +140565,12 @@ pub static WORD_FOLLF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_FOLLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLE_CHILDREN),
+static WORD_FOLLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -140608,23 +140608,23 @@ pub static WORD_FOLLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FOLLD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLD_CHILDREN),
+static WORD_FOLLD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["folder"]],
     range: 2..=2,
 };
 
-static WORD_FOLF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLF_CHILDREN),
+static WORD_FOLF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -140633,12 +140633,12 @@ pub static WORD_FOLF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_FOLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLE_CHILDREN),
+static WORD_FOLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -140647,23 +140647,23 @@ pub static WORD_FOLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_FOLD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLD_CHILDREN),
+static WORD_FOLD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["folder", "fold"]],
     range: 1..=1,
 };
 
-static WORD_FOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOI_CHILDREN),
+static WORD_FOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nters"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -140673,12 +140673,12 @@ pub static WORD_FOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOG_CHILDREN),
+static WORD_FOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -140689,23 +140689,23 @@ pub static WORD_FOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_FOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOF_CHILDREN),
+static WORD_FOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOF_CHILDREN),
     value: Some(&["for"]),
 };
 
-pub static WORD_FOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOD_CHILDREN),
+static WORD_FOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -140723,12 +140723,12 @@ pub static WORD_FOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_FOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOC_CHILDREN),
+static WORD_FOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("u"),
@@ -140752,12 +140752,12 @@ pub static WORD_FOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FN_CHILDREN),
+static WORD_FN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aatic"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -140775,23 +140775,23 @@ pub static WORD_FN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_FM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FM_CHILDREN),
+static WORD_FM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aily")],
     values: &[&["family"]],
     range: 4..=4,
 };
 
-static WORD_FL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FL_CHILDREN),
+static WORD_FL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FL_CHILDREN),
     value: None,
 };
 
-static WORD_FL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FLA_NODE),
     None,
     Some(&WORD_FLC_NODE),
@@ -140820,23 +140820,23 @@ static WORD_FL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLY_CHILDREN),
+static WORD_FLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["flies", "flyers"]],
     range: 2..=2,
 };
 
-static WORD_FLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLU_CHILDREN),
+static WORD_FLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctaute"),
         dictgen::InsensitiveStr::Ascii("ctiations"),
@@ -140890,23 +140890,23 @@ pub static WORD_FLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLT_CHILDREN),
+static WORD_FLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["filter"]],
     range: 2..=2,
 };
 
-static WORD_FLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLO_CHILDREN),
+static WORD_FLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ading"),
         dictgen::InsensitiveStr::Ascii("aring"),
@@ -140954,23 +140954,23 @@ pub static WORD_FLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLL_CHILDREN),
+static WORD_FLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("owing")],
     values: &[&["following", "flowing"]],
     range: 5..=5,
 };
 
-static WORD_FLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLI_CHILDREN),
+static WORD_FLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ename"),
@@ -140996,12 +140996,12 @@ pub static WORD_FLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_FLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLE_CHILDREN),
+static WORD_FLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLE_CHILDREN),
     value: Some(&["file"]),
 };
 
-pub static WORD_FLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("chter"),
@@ -141053,23 +141053,23 @@ pub static WORD_FLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLC_CHILDREN),
+static WORD_FLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iker")],
     values: &[&["flicker"]],
     range: 4..=4,
 };
 
-static WORD_FLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLA_CHILDREN),
+static WORD_FLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cons"),
         dictgen::InsensitiveStr::Ascii("cor"),
@@ -141195,12 +141195,12 @@ pub static WORD_FLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FI_CHILDREN),
+static WORD_FI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FI_CHILDREN),
     value: None,
 };
 
-static WORD_FI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FIA_NODE),
     Some(&WORD_FIB_NODE),
     Some(&WORD_FIC_NODE),
@@ -141229,23 +141229,23 @@ static WORD_FI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_FIZ_NODE),
 ];
 
-static WORD_FIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIZ_CHILDREN),
+static WORD_FIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eek")],
     values: &[&["physique"]],
     range: 3..=3,
 };
 
-static WORD_FIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIX_CHILDREN),
+static WORD_FIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -141265,34 +141265,34 @@ pub static WORD_FIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_FIW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIW_CHILDREN),
+static WORD_FIW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIW_CHILDREN),
     value: Some(&["fix"]),
 };
 
-pub static WORD_FIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIV_CHILDREN),
+static WORD_FIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ety")],
     values: &[&["fifty"]],
     range: 3..=3,
 };
 
-static WORD_FIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIT_CHILDREN),
+static WORD_FIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ering"),
@@ -141316,12 +141316,12 @@ pub static WORD_FIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_FIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIS_CHILDREN),
+static WORD_FIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ionable"),
@@ -141339,12 +141339,12 @@ pub static WORD_FIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_FIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIR_CHILDREN),
+static WORD_FIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ball"),
         dictgen::InsensitiveStr::Ascii("day"),
@@ -141442,12 +141442,12 @@ pub static WORD_FIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIO_CHILDREN),
+static WORD_FIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rget"),
@@ -141457,12 +141457,12 @@ pub static WORD_FIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_FIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FIN_CHILDREN),
+static WORD_FIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FIN_CHILDREN),
     value: None,
 };
 
-static WORD_FIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FINA_NODE),
     None,
     Some(&WORD_FINC_NODE),
@@ -141491,12 +141491,12 @@ static WORD_FIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FINX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINX_CHILDREN),
+static WORD_FINX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -141505,12 +141505,12 @@ pub static WORD_FINX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_FINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINT_CHILDREN),
+static WORD_FINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("uned"),
@@ -141519,12 +141519,12 @@ pub static WORD_FINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_FINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINS_CHILDREN),
+static WORD_FINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hed"),
@@ -141550,12 +141550,12 @@ pub static WORD_FINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FINN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINN_CHILDREN),
+static WORD_FINN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aly"),
         dictgen::InsensitiveStr::Ascii("ess"),
@@ -141573,12 +141573,12 @@ pub static WORD_FINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_FINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINI_CHILDREN),
+static WORD_FINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alization"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -141626,12 +141626,12 @@ pub static WORD_FINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_FING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FING_CHILDREN),
+static WORD_FING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FING_CHILDREN),
     value: Some(&["find"]),
 };
 
-pub static WORD_FING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eprint"),
@@ -141667,23 +141667,23 @@ pub static WORD_FING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_FINF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINF_CHILDREN),
+static WORD_FINF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINF_CHILDREN),
     value: Some(&["find"]),
 };
 
-pub static WORD_FINF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FINE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINE_CHILDREN),
+static WORD_FINE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lly"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -141694,12 +141694,12 @@ pub static WORD_FINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_FIND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIND_CHILDREN),
+static WORD_FIND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIND_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -141709,12 +141709,12 @@ pub static WORD_FIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_FINC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINC_CHILDREN),
+static WORD_FINC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -141734,12 +141734,12 @@ pub static WORD_FINC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_FINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINA_CHILDREN),
+static WORD_FINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cee"),
@@ -141793,12 +141793,12 @@ pub static WORD_FINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_FIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIM_CHILDREN),
+static WORD_FIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ilies"),
@@ -141814,12 +141814,12 @@ pub static WORD_FIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FIL_CHILDREN),
+static WORD_FIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FIL_CHILDREN),
     value: None,
 };
 
-static WORD_FIL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FIL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FILA_NODE),
     None,
     Some(&WORD_FILC_NODE),
@@ -141848,12 +141848,12 @@ static WORD_FIL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FILT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILT_CHILDREN),
+static WORD_FILT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erd"),
         dictgen::InsensitiveStr::Ascii("erig"),
@@ -141879,12 +141879,12 @@ pub static WORD_FILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_FILS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILS_CHILDREN),
+static WORD_FILS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILS_CHILDREN),
     value: Some(&["fills", "files", "file"]),
 };
 
-pub static WORD_FILS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ystem"),
@@ -141894,12 +141894,12 @@ pub static WORD_FILS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FILP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILP_CHILDREN),
+static WORD_FILP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILP_CHILDREN),
     value: Some(&["flip"]),
 };
 
-pub static WORD_FILP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ped"),
         dictgen::InsensitiveStr::Ascii("ping"),
@@ -141909,12 +141909,12 @@ pub static WORD_FILP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_FILN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILN_CHILDREN),
+static WORD_FILN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ame"),
@@ -141923,12 +141923,12 @@ pub static WORD_FILN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_FILM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILM_CHILDREN),
+static WORD_FILM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amkers"),
         dictgen::InsensitiveStr::Ascii("makare"),
@@ -141938,12 +141938,12 @@ pub static WORD_FILM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_FILL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILL_CHILDREN),
+static WORD_FILL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -141965,12 +141965,12 @@ pub static WORD_FILL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FILI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILI_CHILDREN),
+static WORD_FILI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ament"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -141979,23 +141979,23 @@ pub static WORD_FILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_FILF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILF_CHILDREN),
+static WORD_FILF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ills")],
     values: &[&["fulfills"]],
     range: 4..=4,
 };
 
-static WORD_FILE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILE_CHILDREN),
+static WORD_FILE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bame"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -142065,45 +142065,45 @@ pub static WORD_FILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_FILC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILC_CHILDREN),
+static WORD_FILC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ker")],
     values: &[&["flicker"]],
     range: 3..=3,
 };
 
-static WORD_FILA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILA_CHILDREN),
+static WORD_FILA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["final"]],
     range: 1..=1,
 };
 
-static WORD_FIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIK_CHILDREN),
+static WORD_FIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["file"]],
     range: 1..=1,
 };
 
-static WORD_FIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIG_CHILDREN),
+static WORD_FIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hitng"),
         dictgen::InsensitiveStr::Ascii("htings"),
@@ -142139,12 +142139,12 @@ pub static WORD_FIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=10,
 };
 
-static WORD_FIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIF_CHILDREN),
+static WORD_FIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erox"),
         dictgen::InsensitiveStr::Ascii("ferent"),
@@ -142154,12 +142154,12 @@ pub static WORD_FIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIE_CHILDREN),
+static WORD_FIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dl"),
@@ -142201,12 +142201,12 @@ pub static WORD_FIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FID_CHILDREN),
+static WORD_FID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FID_CHILDREN),
     value: None,
 };
 
-pub static WORD_FID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ality"),
         dictgen::InsensitiveStr::Ascii("dley"),
@@ -142228,12 +142228,12 @@ pub static WORD_FID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIC_CHILDREN),
+static WORD_FIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ks"),
         dictgen::InsensitiveStr::Ascii("ticious"),
@@ -142253,12 +142253,12 @@ pub static WORD_FIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIB_CHILDREN),
+static WORD_FIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onaacci"),
         dictgen::InsensitiveStr::Ascii("onnacci"),
@@ -142267,12 +142267,12 @@ pub static WORD_FIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=7,
 };
 
-static WORD_FIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIA_CHILDREN),
+static WORD_FIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ls"),
         dictgen::InsensitiveStr::Ascii("ncial"),
@@ -142290,23 +142290,23 @@ pub static WORD_FIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_FH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FH_CHILDREN),
+static WORD_FH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FH_CHILDREN),
     value: None,
 };
 
-pub static WORD_FH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("urter")],
     values: &[&["further"]],
     range: 5..=5,
 };
 
-static WORD_FF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FF_CHILDREN),
+static WORD_FF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("rom"),
@@ -142315,12 +142315,12 @@ pub static WORD_FF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_FE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FE_CHILDREN),
+static WORD_FE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FE_CHILDREN),
     value: None,
 };
 
-static WORD_FE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FEA_NODE),
     Some(&WORD_FEB_NODE),
     Some(&WORD_FEC_NODE),
@@ -142349,34 +142349,34 @@ static WORD_FE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_FEZ_NODE),
 ];
 
-static WORD_FEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEZ_CHILDREN),
+static WORD_FEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ent")],
     values: &[&["pheasant"]],
     range: 3..=3,
 };
 
-static WORD_FEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEX_CHILDREN),
+static WORD_FEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ibility")],
     values: &[&["flexibility"]],
     range: 7..=7,
 };
 
-static WORD_FEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEW_CHILDREN),
+static WORD_FEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -142386,12 +142386,12 @@ pub static WORD_FEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_FET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FET_CHILDREN),
+static WORD_FET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FET_CHILDREN),
     value: None,
 };
 
-pub static WORD_FET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aure"),
         dictgen::InsensitiveStr::Ascii("aures"),
@@ -142419,12 +142419,12 @@ pub static WORD_FET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_FES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FES_CHILDREN),
+static WORD_FES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FES_CHILDREN),
     value: None,
 };
 
-pub static WORD_FES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("itvals"),
@@ -142446,12 +142446,12 @@ pub static WORD_FES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_FER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FER_CHILDREN),
+static WORD_FER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FER_CHILDREN),
     value: None,
 };
 
-pub static WORD_FER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("buary"),
         dictgen::InsensitiveStr::Ascii("mantation"),
@@ -142497,23 +142497,23 @@ pub static WORD_FER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_FEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEQ_CHILDREN),
+static WORD_FEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uency")],
     values: &[&["frequency"]],
     range: 5..=5,
 };
 
-static WORD_FEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEO_CHILDREN),
+static WORD_FEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dras"),
         dictgen::InsensitiveStr::Ascii("nsay"),
@@ -142522,12 +142522,12 @@ pub static WORD_FEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_FEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEM_CHILDREN),
+static WORD_FEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inen"),
         dictgen::InsensitiveStr::Ascii("inie"),
@@ -142563,12 +142563,12 @@ pub static WORD_FEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_FEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEL_CHILDREN),
+static WORD_FEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("isatus"),
@@ -142590,12 +142590,12 @@ pub static WORD_FEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_FEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEI_CHILDREN),
+static WORD_FEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("lding"),
@@ -142613,12 +142613,12 @@ pub static WORD_FEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_FEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEE_CHILDREN),
+static WORD_FEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("back"),
         dictgen::InsensitiveStr::Ascii("dbakc"),
@@ -142642,12 +142642,12 @@ pub static WORD_FEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FED_CHILDREN),
+static WORD_FED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FED_CHILDREN),
     value: None,
 };
 
-pub static WORD_FED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ality"),
         dictgen::InsensitiveStr::Ascii("back"),
@@ -142673,12 +142673,12 @@ pub static WORD_FED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_FEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEC_CHILDREN),
+static WORD_FEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hes"),
         dictgen::InsensitiveStr::Ascii("thed"),
@@ -142689,12 +142689,12 @@ pub static WORD_FEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_FEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEB_CHILDREN),
+static WORD_FEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bruary"),
         dictgen::InsensitiveStr::Ascii("ewary"),
@@ -142718,12 +142718,12 @@ pub static WORD_FEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_FEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEA_CHILDREN),
+static WORD_FEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ls"),
         dictgen::InsensitiveStr::Ascii("sabile"),
@@ -142791,23 +142791,23 @@ pub static WORD_FEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_FC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FC_CHILDREN),
+static WORD_FC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ound")],
     values: &[&["found"]],
     range: 4..=4,
 };
 
-static WORD_FA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FA_CHILDREN),
+static WORD_FA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FA_CHILDREN),
     value: None,
 };
 
-static WORD_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_FAB_NODE),
     Some(&WORD_FAC_NODE),
@@ -142836,23 +142836,23 @@ static WORD_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAY_CHILDREN),
+static WORD_FAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mus")],
     values: &[&["famous"]],
     range: 3..=3,
 };
 
-static WORD_FAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAV_CHILDREN),
+static WORD_FAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orit"),
         dictgen::InsensitiveStr::Ascii("oritisme"),
@@ -142892,12 +142892,12 @@ pub static WORD_FAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_FAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAU_CHILDREN),
+static WORD_FAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ght"),
         dictgen::InsensitiveStr::Ascii("ilure"),
@@ -142929,12 +142929,12 @@ pub static WORD_FAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAT_CHILDREN),
+static WORD_FAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alaties"),
         dictgen::InsensitiveStr::Ascii("alitites"),
@@ -142962,12 +142962,12 @@ pub static WORD_FAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_FAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAS_CHILDREN),
+static WORD_FAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("cianted"),
@@ -143083,12 +143083,12 @@ pub static WORD_FAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_FAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAR_CHILDREN),
+static WORD_FAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cking"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -143130,34 +143130,34 @@ pub static WORD_FAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAP_CHILDREN),
+static WORD_FAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tastically")],
     values: &[&["fantastically"]],
     range: 10..=10,
 };
 
-static WORD_FAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAO_CHILDREN),
+static WORD_FAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ming")],
     values: &[&["foaming"]],
     range: 4..=4,
 };
 
-static WORD_FAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAN_CHILDREN),
+static WORD_FAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aticals"),
         dictgen::InsensitiveStr::Ascii("aticas"),
@@ -143245,12 +143245,12 @@ pub static WORD_FAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_FAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAM_CHILDREN),
+static WORD_FAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ework"),
         dictgen::InsensitiveStr::Ascii("ilair"),
@@ -143316,12 +143316,12 @@ pub static WORD_FAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_FAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAL_CHILDREN),
+static WORD_FAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cones"),
         dictgen::InsensitiveStr::Ascii("esly"),
@@ -143401,12 +143401,12 @@ pub static WORD_FAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAK_CHILDREN),
+static WORD_FAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("tor"),
@@ -143424,12 +143424,12 @@ pub static WORD_FAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAI_CHILDREN),
+static WORD_FAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eld"),
@@ -143521,12 +143521,12 @@ pub static WORD_FAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAH_CHILDREN),
+static WORD_FAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernheit"),
         dictgen::InsensitiveStr::Ascii("renheight"),
@@ -143536,12 +143536,12 @@ pub static WORD_FAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=9,
 };
 
-static WORD_FAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAG_CHILDREN),
+static WORD_FAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gotts"),
         dictgen::InsensitiveStr::Ascii("gotus"),
@@ -143550,12 +143550,12 @@ pub static WORD_FAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_FAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAE_CHILDREN),
+static WORD_FAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ture"),
         dictgen::InsensitiveStr::Ascii("tures"),
@@ -143564,23 +143564,23 @@ pub static WORD_FAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_FAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAD_CHILDREN),
+static WORD_FAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ind")],
     values: &[&["fading"]],
     range: 3..=3,
 };
 
-static WORD_FAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAC_CHILDREN),
+static WORD_FAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ebok"),
@@ -143706,12 +143706,12 @@ pub static WORD_FAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_FAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAB_CHILDREN),
+static WORD_FAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ility"),
         dictgen::InsensitiveStr::Ascii("ircate"),
@@ -143749,12 +143749,12 @@ pub static WORD_FAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_E_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_E_CHILDREN),
+static WORD_E_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_E_CHILDREN),
     value: None,
 };
 
-static WORD_E_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_E_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EA_NODE),
     Some(&WORD_EB_NODE),
     Some(&WORD_EC_NODE),
@@ -143783,23 +143783,23 @@ static WORD_E_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_EZ_NODE),
 ];
 
-static WORD_EZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EZ_CHILDREN),
+static WORD_EZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_EZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("drop")],
     values: &[&["eavesdrop"]],
     range: 4..=4,
 };
 
-static WORD_EY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EY_CHILDREN),
+static WORD_EY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EY_CHILDREN),
     value: None,
 };
 
-pub static WORD_EY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -143841,12 +143841,12 @@ pub static WORD_EY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_EX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EX_CHILDREN),
+static WORD_EX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EX_CHILDREN),
     value: None,
 };
 
-static WORD_EX_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EX_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXA_NODE),
     None,
     Some(&WORD_EXC_NODE),
@@ -143875,12 +143875,12 @@ static WORD_EX_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXU_CHILDREN),
+static WORD_EXU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("berent"),
         dictgen::InsensitiveStr::Ascii("cuted"),
@@ -143898,12 +143898,12 @@ pub static WORD_EXU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_EXT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXT_CHILDREN),
+static WORD_EXT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXT_CHILDREN),
     value: None,
 };
 
-static WORD_EXT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXTA_NODE),
     None,
     None,
@@ -143932,12 +143932,12 @@ static WORD_EXT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTU_CHILDREN),
+static WORD_EXTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rde"),
@@ -143955,34 +143955,34 @@ pub static WORD_EXTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTT_CHILDREN),
+static WORD_EXTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ra")],
     values: &[&["extra"]],
     range: 2..=2,
 };
 
-static WORD_EXTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTS_CHILDREN),
+static WORD_EXTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["existing"]],
     range: 3..=3,
 };
 
-static WORD_EXTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXTR_CHILDREN),
+static WORD_EXTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXTR_CHILDREN),
     value: None,
 };
 
-static WORD_EXTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXTRA_NODE),
     None,
     None,
@@ -144011,34 +144011,34 @@ static WORD_EXTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXTRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRY_CHILDREN),
+static WORD_EXTRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRY_CHILDREN),
     value: Some(&["entry"]),
 };
 
-pub static WORD_EXTRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRU_CHILDREN),
+static WORD_EXTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ciating")],
     values: &[&["excruciating"]],
     range: 7..=7,
 };
 
-static WORD_EXTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRO_CHILDREN),
+static WORD_EXTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ardinarily"),
         dictgen::InsensitiveStr::Ascii("ardinary"),
@@ -144060,23 +144060,23 @@ pub static WORD_EXTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_EXTRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRM_CHILDREN),
+static WORD_EXTRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ities")],
     values: &[&["extremities"]],
     range: 5..=5,
 };
 
-static WORD_EXTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRI_CHILDREN),
+static WORD_EXTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("me"),
         dictgen::InsensitiveStr::Ascii("mely"),
@@ -144096,12 +144096,12 @@ pub static WORD_EXTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRE_CHILDREN),
+static WORD_EXTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("amely"),
@@ -144183,12 +144183,12 @@ pub static WORD_EXTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_EXTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXTRA_CHILDREN),
+static WORD_EXTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXTRA_CHILDREN),
     value: None,
 };
 
-static WORD_EXTRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXTRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXTRAC_NODE),
@@ -144217,12 +144217,12 @@ static WORD_EXTRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXTRAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAX_CHILDREN),
+static WORD_EXTRAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -144240,12 +144240,12 @@ pub static WORD_EXTRAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_EXTRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAV_CHILDREN),
+static WORD_EXTRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agent"),
         dictgen::InsensitiveStr::Ascii("agina"),
@@ -144265,12 +144265,12 @@ pub static WORD_EXTRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_EXTRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAT_CHILDREN),
+static WORD_EXTRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAT_CHILDREN),
     value: Some(&["extract"]),
 };
 
-pub static WORD_EXTRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("errestial"),
@@ -144296,12 +144296,12 @@ pub static WORD_EXTRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_EXTRAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAP_CHILDREN),
+static WORD_EXTRAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("loate"),
@@ -144329,12 +144329,12 @@ pub static WORD_EXTRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_EXTRAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAO_CHILDREN),
+static WORD_EXTRAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("drinarily"),
         dictgen::InsensitiveStr::Ascii("drinary"),
@@ -144372,12 +144372,12 @@ pub static WORD_EXTRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=10,
 };
 
-static WORD_EXTRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAN_CHILDREN),
+static WORD_EXTRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -144386,34 +144386,34 @@ pub static WORD_EXTRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_EXTRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAG_CHILDREN),
+static WORD_EXTRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("avant")],
     values: &[&["extravagant"]],
     range: 5..=5,
 };
 
-static WORD_EXTRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAE_CHILDREN),
+static WORD_EXTRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nous")],
     values: &[&["extraneous"]],
     range: 4..=4,
 };
 
-static WORD_EXTRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAD_CHILDREN),
+static WORD_EXTRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iction"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -144422,12 +144422,12 @@ pub static WORD_EXTRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_EXTRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAC_CHILDREN),
+static WORD_EXTRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAC_CHILDREN),
     value: Some(&["extract"]),
 };
 
-pub static WORD_EXTRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cion"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -144461,12 +144461,12 @@ pub static WORD_EXTRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_EXTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTO_CHILDREN),
+static WORD_EXTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ics"),
         dictgen::InsensitiveStr::Ascii("rtin"),
@@ -144475,12 +144475,12 @@ pub static WORD_EXTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EXTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTN_CHILDREN),
+static WORD_EXTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("end"),
         dictgen::InsensitiveStr::Ascii("esion"),
@@ -144490,12 +144490,12 @@ pub static WORD_EXTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTI_CHILDREN),
+static WORD_EXTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mate"),
         dictgen::InsensitiveStr::Ascii("mated"),
@@ -144535,12 +144535,12 @@ pub static WORD_EXTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXTE_CHILDREN),
+static WORD_EXTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXTE_CHILDREN),
     value: None,
 };
 
-static WORD_EXTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXTE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -144569,12 +144569,12 @@ static WORD_EXTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXTES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTES_CHILDREN),
+static WORD_EXTES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTES_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -144590,12 +144590,12 @@ pub static WORD_EXTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_EXTER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTER_CHILDREN),
+static WORD_EXTER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTER_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("bal"),
@@ -144647,12 +144647,12 @@ pub static WORD_EXTER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_EXTEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTEP_CHILDREN),
+static WORD_EXTEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ecting"),
@@ -144662,12 +144662,12 @@ pub static WORD_EXTEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXTEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTEN_CHILDREN),
+static WORD_EXTEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTEN_CHILDREN),
     value: Some(&["extent"]),
 };
 
-pub static WORD_EXTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -144747,23 +144747,23 @@ pub static WORD_EXTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_EXTEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTEM_CHILDREN),
+static WORD_EXTEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ely")],
     values: &[&["extremely"]],
     range: 3..=3,
 };
 
-static WORD_EXTED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTED_CHILDREN),
+static WORD_EXTED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTED_CHILDREN),
     value: Some(&["extend"]),
 };
 
-pub static WORD_EXTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -144787,12 +144787,12 @@ pub static WORD_EXTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_EXTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTA_CHILDREN),
+static WORD_EXTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTA_CHILDREN),
     value: Some(&["extra"]),
 };
 
-pub static WORD_EXTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -144814,12 +144814,12 @@ pub static WORD_EXTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXS_CHILDREN),
+static WORD_EXS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ist"),
         dictgen::InsensitiveStr::Ascii("istence"),
@@ -144879,12 +144879,12 @@ pub static WORD_EXS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EXR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXR_CHILDREN),
+static WORD_EXR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("act"),
@@ -144906,12 +144906,12 @@ pub static WORD_EXR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_EXP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXP_CHILDREN),
+static WORD_EXP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXP_CHILDREN),
     value: None,
 };
 
-static WORD_EXP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPA_NODE),
     None,
     Some(&WORD_EXPC_NODE),
@@ -144940,23 +144940,23 @@ static WORD_EXP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPT_CHILDREN),
+static WORD_EXPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ected")],
     values: &[&["expected"]],
     range: 5..=5,
 };
 
-static WORD_EXPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPR_CHILDREN),
+static WORD_EXPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eince"),
         dictgen::InsensitiveStr::Ascii("ensive"),
@@ -145060,12 +145060,12 @@ pub static WORD_EXPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_EXPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPP_CHILDREN),
+static WORD_EXPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ressed"),
@@ -145074,12 +145074,12 @@ pub static WORD_EXPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPO_CHILDREN),
+static WORD_EXPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPO_CHILDREN),
     value: None,
 };
 
-static WORD_EXPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXPOC_NODE),
@@ -145108,12 +145108,12 @@ static WORD_EXPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOT_CHILDREN),
+static WORD_EXPOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ential"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -145123,12 +145123,12 @@ pub static WORD_EXPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXPOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOS_CHILDREN),
+static WORD_EXPOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ees"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -145148,12 +145148,12 @@ pub static WORD_EXPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXPOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOR_CHILDREN),
+static WORD_EXPOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ession"),
@@ -145179,12 +145179,12 @@ pub static WORD_EXPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXPON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPON_CHILDREN),
+static WORD_EXPON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPON_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("antation"),
@@ -145228,12 +145228,12 @@ pub static WORD_EXPON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_EXPOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOL_CHILDREN),
+static WORD_EXPOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("des"),
@@ -145267,12 +145267,12 @@ pub static WORD_EXPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXPOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOI_CHILDREN),
+static WORD_EXPOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tation"),
@@ -145288,12 +145288,12 @@ pub static WORD_EXPOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXPOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOE_CHILDREN),
+static WORD_EXPOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cted"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -145317,12 +145317,12 @@ pub static WORD_EXPOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOD_CHILDREN),
+static WORD_EXPOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ential"),
         dictgen::InsensitiveStr::Ascii("entially"),
@@ -145332,23 +145332,23 @@ pub static WORD_EXPOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_EXPOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOC_CHILDREN),
+static WORD_EXPOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["epoch"]],
     range: 1..=1,
 };
 
-static WORD_EXPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPL_CHILDREN),
+static WORD_EXPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPL_CHILDREN),
     value: None,
 };
 
-static WORD_EXPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPLA_NODE),
     None,
     Some(&WORD_EXPLC_NODE),
@@ -145377,23 +145377,23 @@ static WORD_EXPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLU_CHILDREN),
+static WORD_EXPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sions")],
     values: &[&["explosions"]],
     range: 5..=5,
 };
 
-static WORD_EXPLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLO_CHILDREN),
+static WORD_EXPLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deds"),
         dictgen::InsensitiveStr::Ascii("die"),
@@ -145479,12 +145479,12 @@ pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLI_CHILDREN),
+static WORD_EXPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("cat"),
@@ -145590,12 +145590,12 @@ pub static WORD_EXPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLE_CHILDREN),
+static WORD_EXPLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cit"),
         dictgen::InsensitiveStr::Ascii("citely"),
@@ -145617,12 +145617,12 @@ pub static WORD_EXPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EXPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLC_CHILDREN),
+static WORD_EXPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("itely"),
@@ -145632,12 +145632,12 @@ pub static WORD_EXPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLA_CHILDREN),
+static WORD_EXPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ination"),
         dictgen::InsensitiveStr::Ascii("inations"),
@@ -145695,12 +145695,12 @@ pub static WORD_EXPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_EXPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPI_CHILDREN),
+static WORD_EXPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cit"),
         dictgen::InsensitiveStr::Ascii("citly"),
@@ -145782,12 +145782,12 @@ pub static WORD_EXPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_EXPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPE_CHILDREN),
+static WORD_EXPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPE_CHILDREN),
     value: None,
 };
 
-static WORD_EXPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXPEC_NODE),
@@ -145816,12 +145816,12 @@ static WORD_EXPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEX_CHILDREN),
+static WORD_EXPEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -145855,12 +145855,12 @@ pub static WORD_EXPEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEW_CHILDREN),
+static WORD_EXPEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("riment"),
         dictgen::InsensitiveStr::Ascii("rimental"),
@@ -145892,12 +145892,12 @@ pub static WORD_EXPEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=12,
 };
 
-static WORD_EXPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPET_CHILDREN),
+static WORD_EXPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPET_CHILDREN),
     value: Some(&["expect", "expat"]),
 };
 
-pub static WORD_EXPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancy"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -145979,12 +145979,12 @@ pub static WORD_EXPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_EXPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPES_CHILDREN),
+static WORD_EXPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -146026,12 +146026,12 @@ pub static WORD_EXPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_EXPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPER_CHILDREN),
+static WORD_EXPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPER_CHILDREN),
     value: None,
 };
 
-static WORD_EXPER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPERA_NODE),
     None,
     Some(&WORD_EXPERC_NODE),
@@ -146060,12 +146060,12 @@ static WORD_EXPER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERT_CHILDREN),
+static WORD_EXPERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -146076,12 +146076,12 @@ pub static WORD_EXPERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_EXPERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERS_CHILDREN),
+static WORD_EXPERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERS_CHILDREN),
     value: Some(&["express"]),
 };
 
-pub static WORD_EXPERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -146115,23 +146115,23 @@ pub static WORD_EXPERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_EXPERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERN_CHILDREN),
+static WORD_EXPERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["external"]],
     range: 2..=2,
 };
 
-static WORD_EXPERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERM_CHILDREN),
+static WORD_EXPERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enet"),
         dictgen::InsensitiveStr::Ascii("enetal"),
@@ -146247,12 +146247,12 @@ pub static WORD_EXPERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=11,
 };
 
-static WORD_EXPERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPERI_CHILDREN),
+static WORD_EXPERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPERI_CHILDREN),
     value: None,
 };
 
-static WORD_EXPERI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPERI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPERIA_NODE),
     None,
     Some(&WORD_EXPERIC_NODE),
@@ -146281,12 +146281,12 @@ static WORD_EXPERI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPERIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIR_CHILDREN),
+static WORD_EXPERIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -146295,12 +146295,12 @@ pub static WORD_EXPERIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=6,
 };
 
-static WORD_EXPERIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIN_CHILDREN),
+static WORD_EXPERIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -146344,12 +146344,12 @@ pub static WORD_EXPERIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=11,
 };
 
-static WORD_EXPERIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPERIM_CHILDREN),
+static WORD_EXPERIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPERIM_CHILDREN),
     value: Some(&["experiment"]),
 };
 
-static WORD_EXPERIM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPERIM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPERIMA_NODE),
     None,
     None,
@@ -146378,12 +146378,12 @@ static WORD_EXPERIM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPERIMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMT_CHILDREN),
+static WORD_EXPERIMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("enal"),
@@ -146415,23 +146415,23 @@ pub static WORD_EXPERIMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=8,
 };
 
-static WORD_EXPERIMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMS_CHILDREN),
+static WORD_EXPERIMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMS_CHILDREN),
     value: Some(&["experiments"]),
 };
 
-pub static WORD_EXPERIMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXPERIMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMN_CHILDREN),
+static WORD_EXPERIMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etal"),
@@ -146487,12 +146487,12 @@ pub static WORD_EXPERIMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_EXPERIMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMM_CHILDREN),
+static WORD_EXPERIMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ental"),
@@ -146524,12 +146524,12 @@ pub static WORD_EXPERIMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 3..=9,
 };
 
-static WORD_EXPERIMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMI_CHILDREN),
+static WORD_EXPERIMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -146563,12 +146563,12 @@ pub static WORD_EXPERIMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=8,
 };
 
-static WORD_EXPERIME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPERIME_CHILDREN),
+static WORD_EXPERIME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPERIME_CHILDREN),
     value: None,
 };
 
-static WORD_EXPERIME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPERIME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -146597,12 +146597,12 @@ static WORD_EXPERIME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPERIMET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMET_CHILDREN),
+static WORD_EXPERIMET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMET_CHILDREN),
     value: Some(&["experiments", "experiment"]),
 };
 
-pub static WORD_EXPERIMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -146680,23 +146680,23 @@ pub static WORD_EXPERIMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=9,
 };
 
-static WORD_EXPERIMER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMER_CHILDREN),
+static WORD_EXPERIMER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMER_CHILDREN),
     value: Some(&["experimenter"]),
 };
 
-pub static WORD_EXPERIMER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["experimenters"]],
     range: 1..=1,
 };
 
-static WORD_EXPERIMEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPERIMEN_CHILDREN),
+static WORD_EXPERIMEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPERIMEN_CHILDREN),
     value: Some(&["experiment"]),
 };
 
-static WORD_EXPERIMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPERIMEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPERIMENA_NODE),
     None,
     None,
@@ -146725,12 +146725,12 @@ static WORD_EXPERIMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] =
     None,
 ];
 
-static WORD_EXPERIMENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENT_CHILDREN),
+static WORD_EXPERIMENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aal"),
         dictgen::InsensitiveStr::Ascii("aally"),
@@ -146838,34 +146838,34 @@ pub static WORD_EXPERIMENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::Dict
     range: 1..=8,
 };
 
-static WORD_EXPERIMENS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENS_CHILDREN),
+static WORD_EXPERIMENS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENS_CHILDREN),
     value: Some(&["experiments"]),
 };
 
-pub static WORD_EXPERIMENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXPERIMENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENI_CHILDREN),
+static WORD_EXPERIMENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["experimenting"]],
     range: 2..=2,
 };
 
-static WORD_EXPERIMENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENE_CHILDREN),
+static WORD_EXPERIMENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -146883,12 +146883,12 @@ pub static WORD_EXPERIMENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::Dict
     range: 1..=3,
 };
 
-static WORD_EXPERIMENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENA_CHILDREN),
+static WORD_EXPERIMENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -146928,34 +146928,34 @@ pub static WORD_EXPERIMENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::Dict
     range: 1..=7,
 };
 
-static WORD_EXPERIMEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMEL_CHILDREN),
+static WORD_EXPERIMEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMEL_CHILDREN),
     value: Some(&["experimental"]),
 };
 
-pub static WORD_EXPERIMEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["experimentally"]],
     range: 2..=2,
 };
 
-static WORD_EXPERIMED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMED_CHILDREN),
+static WORD_EXPERIMED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMED_CHILDREN),
     value: Some(&["experimented"]),
 };
 
-pub static WORD_EXPERIMED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXPERIMD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMD_CHILDREN),
+static WORD_EXPERIMD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("ntal"),
@@ -146987,12 +146987,12 @@ pub static WORD_EXPERIMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=8,
 };
 
-static WORD_EXPERIMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMA_CHILDREN),
+static WORD_EXPERIMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -147080,12 +147080,12 @@ pub static WORD_EXPERIMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=10,
 };
 
-static WORD_EXPERIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIE_CHILDREN),
+static WORD_EXPERIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -147131,12 +147131,12 @@ pub static WORD_EXPERIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_EXPERIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIC_CHILDREN),
+static WORD_EXPERIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -147154,12 +147154,12 @@ pub static WORD_EXPERIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_EXPERIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIA_CHILDREN),
+static WORD_EXPERIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nce"),
         dictgen::InsensitiveStr::Ascii("nced"),
@@ -147185,12 +147185,12 @@ pub static WORD_EXPERIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=5,
 };
 
-static WORD_EXPERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERE_CHILDREN),
+static WORD_EXPERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icne"),
         dictgen::InsensitiveStr::Ascii("ience"),
@@ -147262,12 +147262,12 @@ pub static WORD_EXPERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_EXPERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERC_CHILDREN),
+static WORD_EXPERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -147283,12 +147283,12 @@ pub static WORD_EXPERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_EXPERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERA_CHILDREN),
+static WORD_EXPERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mental"),
@@ -147324,12 +147324,12 @@ pub static WORD_EXPERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=10,
 };
 
-static WORD_EXPEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEP_CHILDREN),
+static WORD_EXPEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -147361,12 +147361,12 @@ pub static WORD_EXPEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEN_CHILDREN),
+static WORD_EXPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -147406,12 +147406,12 @@ pub static WORD_EXPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXPEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEM_CHILDREN),
+static WORD_EXPEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ental"),
@@ -147463,12 +147463,12 @@ pub static WORD_EXPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_EXPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEL_CHILDREN),
+static WORD_EXPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ls"),
@@ -147477,12 +147477,12 @@ pub static WORD_EXPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_EXPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEI_CHILDREN),
+static WORD_EXPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -147548,12 +147548,12 @@ pub static WORD_EXPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_EXPEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEE_CHILDREN),
+static WORD_EXPEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -147577,12 +147577,12 @@ pub static WORD_EXPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPED_CHILDREN),
+static WORD_EXPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etion"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -147604,12 +147604,12 @@ pub static WORD_EXPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EXPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEC_CHILDREN),
+static WORD_EXPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atation"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -147675,12 +147675,12 @@ pub static WORD_EXPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_EXPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPC_CHILDREN),
+static WORD_EXPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eption"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -147712,12 +147712,12 @@ pub static WORD_EXPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_EXPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPA_CHILDREN),
+static WORD_EXPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("lin"),
@@ -147785,12 +147785,12 @@ pub static WORD_EXPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXO_CHILDREN),
+static WORD_EXO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itcs"),
         dictgen::InsensitiveStr::Ascii("licit"),
@@ -147828,12 +147828,12 @@ pub static WORD_EXO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EXN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXN_CHILDREN),
+static WORD_EXN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ternal"),
         dictgen::InsensitiveStr::Ascii("ternalities"),
@@ -147851,12 +147851,12 @@ pub static WORD_EXN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_EXM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXM_CHILDREN),
+static WORD_EXM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aine"),
         dictgen::InsensitiveStr::Ascii("ained"),
@@ -147882,12 +147882,12 @@ pub static WORD_EXM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_EXL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXL_CHILDREN),
+static WORD_EXL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amation"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -147963,12 +147963,12 @@ pub static WORD_EXL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_EXI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXI_CHILDREN),
+static WORD_EXI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXI_CHILDREN),
     value: None,
 };
 
-static WORD_EXI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_EXIB_NODE),
     Some(&WORD_EXIC_NODE),
@@ -147997,12 +147997,12 @@ static WORD_EXI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIX_CHILDREN),
+static WORD_EXIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("st"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -148013,12 +148013,12 @@ pub static WORD_EXIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_EXIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIT_CHILDREN),
+static WORD_EXIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -148046,12 +148046,12 @@ pub static WORD_EXIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIS_CHILDREN),
+static WORD_EXIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -148129,12 +148129,12 @@ pub static WORD_EXIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIP_CHILDREN),
+static WORD_EXIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ration"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -148145,23 +148145,23 @@ pub static WORD_EXIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIN_CHILDREN),
+static WORD_EXIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ct")],
     values: &[&["extinct"]],
     range: 2..=2,
 };
 
-static WORD_EXIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIL_CHILDREN),
+static WORD_EXIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erate"),
         dictgen::InsensitiveStr::Ascii("erated"),
@@ -148177,12 +148177,12 @@ pub static WORD_EXIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_EXIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIC_CHILDREN),
+static WORD_EXIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ted"),
         dictgen::InsensitiveStr::Ascii("tement"),
@@ -148206,12 +148206,12 @@ pub static WORD_EXIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EXIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIB_CHILDREN),
+static WORD_EXIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("itions"),
@@ -148220,12 +148220,12 @@ pub static WORD_EXIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_EXH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXH_CHILDREN),
+static WORD_EXH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alted"),
         dictgen::InsensitiveStr::Ascii("ange"),
@@ -148317,12 +148317,12 @@ pub static WORD_EXH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_EXE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXE_CHILDREN),
+static WORD_EXE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXE_CHILDREN),
     value: None,
 };
 
-static WORD_EXE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXEC_NODE),
@@ -148351,23 +148351,23 @@ static WORD_EXE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEX_CHILDREN),
+static WORD_EXEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utable")],
     values: &[&["executable"]],
     range: 6..=6,
 };
 
-static WORD_EXEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEU_CHILDREN),
+static WORD_EXEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cte"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -148393,23 +148393,23 @@ pub static WORD_EXEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EXES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXES_CHILDREN),
+static WORD_EXES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXES_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sive")],
     values: &[&["excessive"]],
     range: 4..=4,
 };
 
-static WORD_EXER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXER_CHILDREN),
+static WORD_EXER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXER_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bate"),
         dictgen::InsensitiveStr::Ascii("bated"),
@@ -148489,23 +148489,23 @@ pub static WORD_EXER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEQ_CHILDREN),
+static WORD_EXEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ution")],
     values: &[&["execution"]],
     range: 5..=5,
 };
 
-static WORD_EXEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEP_CHILDREN),
+static WORD_EXEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -148549,12 +148549,12 @@ pub static WORD_EXEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_EXEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEN_CHILDREN),
+static WORD_EXEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -148572,12 +148572,12 @@ pub static WORD_EXEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEM_CHILDREN),
+static WORD_EXEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pel"),
         dictgen::InsensitiveStr::Ascii("pels"),
@@ -148588,12 +148588,12 @@ pub static WORD_EXEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EXEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEL_CHILDREN),
+static WORD_EXEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("lent"),
@@ -148602,12 +148602,12 @@ pub static WORD_EXEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EXEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEG_CHILDREN),
+static WORD_EXEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gerating"),
         dictgen::InsensitiveStr::Ascii("geration"),
@@ -148616,12 +148616,12 @@ pub static WORD_EXEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=8,
 };
 
-static WORD_EXEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEE_CHILDREN),
+static WORD_EXEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cutable"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -148641,12 +148641,12 @@ pub static WORD_EXEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXEC_CHILDREN),
+static WORD_EXEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXEC_CHILDREN),
     value: None,
 };
 
-static WORD_EXEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -148675,12 +148675,12 @@ static WORD_EXEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXECU_CHILDREN),
+static WORD_EXECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXECU_CHILDREN),
     value: None,
 };
 
-static WORD_EXECU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXECU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXECUA_NODE),
     Some(&WORD_EXECUB_NODE),
     Some(&WORD_EXECUC_NODE),
@@ -148709,12 +148709,12 @@ static WORD_EXECU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXECUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXECUT_CHILDREN),
+static WORD_EXECUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXECUT_CHILDREN),
     value: Some(&["execute"]),
 };
 
-static WORD_EXECUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXECUT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXECUTA_NODE),
     Some(&WORD_EXECUTB_NODE),
     None,
@@ -148743,12 +148743,12 @@ static WORD_EXECUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXECUTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTU_CHILDREN),
+static WORD_EXECUTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -148792,12 +148792,12 @@ pub static WORD_EXECUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_EXECUTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTT_CHILDREN),
+static WORD_EXECUTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -148807,23 +148807,23 @@ pub static WORD_EXECUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_EXECUTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTS_CHILDREN),
+static WORD_EXECUTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTS_CHILDREN),
     value: Some(&["executes"]),
 };
 
-pub static WORD_EXECUTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXECUTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTR_CHILDREN),
+static WORD_EXECUTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -148833,34 +148833,34 @@ pub static WORD_EXECUTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=2,
 };
 
-static WORD_EXECUTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTO_CHILDREN),
+static WORD_EXECUTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("n")],
     values: &[&["execution"]],
     range: 1..=1,
 };
 
-static WORD_EXECUTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTN_CHILDREN),
+static WORD_EXECUTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["executing"]],
     range: 1..=1,
 };
 
-static WORD_EXECUTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTI_CHILDREN),
+static WORD_EXECUTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -148902,12 +148902,12 @@ pub static WORD_EXECUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_EXECUTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTE_CHILDREN),
+static WORD_EXECUTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -148916,23 +148916,23 @@ pub static WORD_EXECUTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=5,
 };
 
-static WORD_EXECUTD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTD_CHILDREN),
+static WORD_EXECUTD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTD_CHILDREN),
     value: Some(&["executed"]),
 };
 
-pub static WORD_EXECUTD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["executing"]],
     range: 3..=3,
 };
 
-static WORD_EXECUTB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTB_CHILDREN),
+static WORD_EXECUTB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -148948,12 +148948,12 @@ pub static WORD_EXECUTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_EXECUTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTA_CHILDREN),
+static WORD_EXECUTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bable"),
         dictgen::InsensitiveStr::Ascii("bables"),
@@ -148991,12 +148991,12 @@ pub static WORD_EXECUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_EXECUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUS_CHILDREN),
+static WORD_EXECUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149020,12 +149020,12 @@ pub static WORD_EXECUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_EXECUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUR_CHILDREN),
+static WORD_EXECUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -149043,12 +149043,12 @@ pub static WORD_EXECUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_EXECUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUN_CHILDREN),
+static WORD_EXECUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149059,12 +149059,12 @@ pub static WORD_EXECUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_EXECUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUL_CHILDREN),
+static WORD_EXECUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atble"),
         dictgen::InsensitiveStr::Ascii("atbles"),
@@ -149082,12 +149082,12 @@ pub static WORD_EXECUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_EXECUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUI_CHILDREN),
+static WORD_EXECUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -149117,12 +149117,12 @@ pub static WORD_EXECUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_EXECUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUE_CHILDREN),
+static WORD_EXECUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUE_CHILDREN),
     value: Some(&["execute"]),
 };
 
-pub static WORD_EXECUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -149148,12 +149148,12 @@ pub static WORD_EXECUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_EXECUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUD_CHILDREN),
+static WORD_EXECUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149169,12 +149169,12 @@ pub static WORD_EXECUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_EXECUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUC_CHILDREN),
+static WORD_EXECUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("te"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -149196,12 +149196,12 @@ pub static WORD_EXECUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_EXECUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUB_CHILDREN),
+static WORD_EXECUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -149210,12 +149210,12 @@ pub static WORD_EXECUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_EXECUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUA_CHILDREN),
+static WORD_EXECUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bles"),
@@ -149245,12 +149245,12 @@ pub static WORD_EXECUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_EXECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECT_CHILDREN),
+static WORD_EXECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149314,12 +149314,12 @@ pub static WORD_EXECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXECP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECP_CHILDREN),
+static WORD_EXECP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -149335,12 +149335,12 @@ pub static WORD_EXECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECI_CHILDREN),
+static WORD_EXECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -149360,12 +149360,12 @@ pub static WORD_EXECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECE_CHILDREN),
+static WORD_EXECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cutable"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149387,23 +149387,23 @@ pub static WORD_EXECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXD_CHILDREN),
+static WORD_EXD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cutive")],
     values: &[&["executive"]],
     range: 6..=6,
 };
 
-static WORD_EXC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXC_CHILDREN),
+static WORD_EXC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXC_CHILDREN),
     value: None,
 };
 
-static WORD_EXC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXCA_NODE),
     None,
     Some(&WORD_EXCC_NODE),
@@ -149432,12 +149432,12 @@ static WORD_EXC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCU_CHILDREN),
+static WORD_EXCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lde"),
         dictgen::InsensitiveStr::Ascii("lded"),
@@ -149483,12 +149483,12 @@ pub static WORD_EXCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_EXCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCT_CHILDREN),
+static WORD_EXCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acted"),
         dictgen::InsensitiveStr::Ascii("ract"),
@@ -149512,12 +149512,12 @@ pub static WORD_EXCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_EXCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCR_CHILDREN),
+static WORD_EXCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("ept"),
@@ -149533,12 +149533,12 @@ pub static WORD_EXCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_EXCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCP_CHILDREN),
+static WORD_EXCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -149576,23 +149576,23 @@ pub static WORD_EXCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCO_CHILDREN),
+static WORD_EXCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rciating")],
     values: &[&["excruciating"]],
     range: 8..=8,
 };
 
-static WORD_EXCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCL_CHILDREN),
+static WORD_EXCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amacion"),
         dictgen::InsensitiveStr::Ascii("amanation"),
@@ -149694,12 +149694,12 @@ pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCI_CHILDREN),
+static WORD_EXCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -149729,12 +149729,12 @@ pub static WORD_EXCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCH_CHILDREN),
+static WORD_EXCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("aged"),
@@ -149844,12 +149844,12 @@ pub static WORD_EXCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXCE_CHILDREN),
+static WORD_EXCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXCE_CHILDREN),
     value: None,
 };
 
-static WORD_EXCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXCE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXCEC_NODE),
@@ -149878,12 +149878,12 @@ static WORD_EXCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXCEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEW_CHILDREN),
+static WORD_EXCEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ption"),
         dictgen::InsensitiveStr::Ascii("ptional"),
@@ -149893,12 +149893,12 @@ pub static WORD_EXCEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_EXCEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEU_CHILDREN),
+static WORD_EXCEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctable"),
         dictgen::InsensitiveStr::Ascii("ctables"),
@@ -149956,12 +149956,12 @@ pub static WORD_EXCEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXCET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCET_CHILDREN),
+static WORD_EXCET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCET_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -150013,12 +150013,12 @@ pub static WORD_EXCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXCES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCES_CHILDREN),
+static WORD_EXCES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCES_CHILDREN),
     value: Some(&["excess"]),
 };
 
-pub static WORD_EXCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -150042,12 +150042,12 @@ pub static WORD_EXCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXCER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCER_CHILDREN),
+static WORD_EXCER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCER_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cise"),
         dictgen::InsensitiveStr::Ascii("cised"),
@@ -150085,12 +150085,12 @@ pub static WORD_EXCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXCEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEP_CHILDREN),
+static WORD_EXCEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cional"),
         dictgen::InsensitiveStr::Ascii("etion"),
@@ -150144,12 +150144,12 @@ pub static WORD_EXCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXCEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEO_CHILDREN),
+static WORD_EXCEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pted"),
@@ -150167,12 +150167,12 @@ pub static WORD_EXCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXCEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEN_CHILDREN),
+static WORD_EXCEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tric"),
         dictgen::InsensitiveStr::Ascii("tricity"),
@@ -150182,12 +150182,12 @@ pub static WORD_EXCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_EXCEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEM_CHILDREN),
+static WORD_EXCEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pted"),
@@ -150205,12 +150205,12 @@ pub static WORD_EXCEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXCEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEL_CHILDREN),
+static WORD_EXCEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("erates"),
@@ -150234,12 +150234,12 @@ pub static WORD_EXCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXCEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEI_CHILDREN),
+static WORD_EXCEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rpt"),
         dictgen::InsensitiveStr::Ascii("rpts"),
@@ -150248,12 +150248,12 @@ pub static WORD_EXCEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EXCEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEE_CHILDREN),
+static WORD_EXCEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("digly"),
         dictgen::InsensitiveStr::Ascii("dinly"),
@@ -150271,12 +150271,12 @@ pub static WORD_EXCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXCED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCED_CHILDREN),
+static WORD_EXCED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCED_CHILDREN),
     value: Some(&["exceed"]),
 };
 
-pub static WORD_EXCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -150300,12 +150300,12 @@ pub static WORD_EXCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_EXCEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEC_CHILDREN),
+static WORD_EXCEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ise"),
         dictgen::InsensitiveStr::Ascii("ised"),
@@ -150385,12 +150385,12 @@ pub static WORD_EXCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCC_CHILDREN),
+static WORD_EXCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eds"),
         dictgen::InsensitiveStr::Ascii("ute"),
@@ -150399,12 +150399,12 @@ pub static WORD_EXCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_EXCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCA_CHILDREN),
+static WORD_EXCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctly"),
@@ -150438,12 +150438,12 @@ pub static WORD_EXCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXA_CHILDREN),
+static WORD_EXA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXA_CHILDREN),
     value: None,
 };
 
-static WORD_EXA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXAC_NODE),
@@ -150472,12 +150472,12 @@ static WORD_EXA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAU_CHILDREN),
+static WORD_EXAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hsted"),
         dictgen::InsensitiveStr::Ascii("hsting"),
@@ -150497,12 +150497,12 @@ pub static WORD_EXAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_EXAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAT_CHILDREN),
+static WORD_EXAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAT_CHILDREN),
     value: Some(&["exact"]),
 };
 
-pub static WORD_EXAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cly"),
         dictgen::InsensitiveStr::Ascii("ctly"),
@@ -150520,23 +150520,23 @@ pub static WORD_EXAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_EXAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAR_CHILDREN),
+static WORD_EXAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cebated")],
     values: &[&["exacerbated"]],
     range: 7..=7,
 };
 
-static WORD_EXAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAP_CHILDREN),
+static WORD_EXAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anded"),
         dictgen::InsensitiveStr::Ascii("anding"),
@@ -150586,12 +150586,12 @@ pub static WORD_EXAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAN_CHILDREN),
+static WORD_EXAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -150601,12 +150601,12 @@ pub static WORD_EXAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_EXAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAM_CHILDREN),
+static WORD_EXAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eple"),
         dictgen::InsensitiveStr::Ascii("eples"),
@@ -150670,12 +150670,12 @@ pub static WORD_EXAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAH_CHILDREN),
+static WORD_EXAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ust"),
         dictgen::InsensitiveStr::Ascii("usted"),
@@ -150691,12 +150691,12 @@ pub static WORD_EXAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAG_CHILDREN),
+static WORD_EXAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erate"),
         dictgen::InsensitiveStr::Ascii("erated"),
@@ -150750,12 +150750,12 @@ pub static WORD_EXAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_EXAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAC_CHILDREN),
+static WORD_EXAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arbated"),
         dictgen::InsensitiveStr::Ascii("berate"),
@@ -150779,12 +150779,12 @@ pub static WORD_EXAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EW_CHILDREN),
+static WORD_EW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EW_CHILDREN),
     value: None,
 };
 
-pub static WORD_EW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hwer"),
         dictgen::InsensitiveStr::Ascii("xception"),
@@ -150793,12 +150793,12 @@ pub static WORD_EW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_EV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EV_CHILDREN),
+static WORD_EV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EV_CHILDREN),
     value: None,
 };
 
-static WORD_EV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EVA_NODE),
     None,
     None,
@@ -150827,23 +150827,23 @@ static WORD_EV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EVY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVY_CHILDREN),
+static WORD_EVY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVY_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rthing")],
     values: &[&["everything"]],
     range: 6..=6,
 };
 
-static WORD_EVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVR_CHILDREN),
+static WORD_EVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eyones"),
         dictgen::InsensitiveStr::Ascii("eytime"),
@@ -150867,12 +150867,12 @@ pub static WORD_EVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_EVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVO_CHILDREN),
+static WORD_EVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("luate"),
         dictgen::InsensitiveStr::Ascii("luated"),
@@ -150910,12 +150910,12 @@ pub static WORD_EVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_EVN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVN_CHILDREN),
+static WORD_EVN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVN_CHILDREN),
     value: Some(&["even"]),
 };
 
-pub static WORD_EVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -150925,12 +150925,12 @@ pub static WORD_EVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_EVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVL_CHILDREN),
+static WORD_EVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oved"),
         dictgen::InsensitiveStr::Ascii("oves"),
@@ -150962,12 +150962,12 @@ pub static WORD_EVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_EVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVI_CHILDREN),
+static WORD_EVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("citon"),
@@ -151001,12 +151001,12 @@ pub static WORD_EVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EVE_CHILDREN),
+static WORD_EVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EVE_CHILDREN),
     value: None,
 };
 
-static WORD_EVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EVE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -151035,12 +151035,12 @@ static WORD_EVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EVEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEY_CHILDREN),
+static WORD_EVEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEY_CHILDREN),
     value: Some(&["every"]),
 };
 
-pub static WORD_EVEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("one"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -151058,23 +151058,23 @@ pub static WORD_EVEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EVET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVET_CHILDREN),
+static WORD_EVET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVET_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ually")],
     values: &[&["eventually"]],
     range: 5..=5,
 };
 
-static WORD_EVES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVES_CHILDREN),
+static WORD_EVES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVES_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("drop"),
         dictgen::InsensitiveStr::Ascii("dropped"),
@@ -151092,12 +151092,12 @@ pub static WORD_EVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_EVER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVER_CHILDREN),
+static WORD_EVER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVER_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("aged"),
@@ -151171,12 +151171,12 @@ pub static WORD_EVER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EVEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEO_CHILDREN),
+static WORD_EVEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lution"),
         dictgen::InsensitiveStr::Ascii("lutionary"),
@@ -151196,12 +151196,12 @@ pub static WORD_EVEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_EVEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEN_CHILDREN),
+static WORD_EVEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("galical"),
         dictgen::InsensitiveStr::Ascii("htually"),
@@ -151229,23 +151229,23 @@ pub static WORD_EVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_EVEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEM_CHILDREN),
+static WORD_EVEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEM_CHILDREN),
     value: Some(&["even", "ever"]),
 };
 
-pub static WORD_EVEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EVEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEL_CHILDREN),
+static WORD_EVEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ope"),
@@ -151275,12 +151275,12 @@ pub static WORD_EVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_EVEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEI_CHILDREN),
+static WORD_EVEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dence"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -151289,12 +151289,12 @@ pub static WORD_EVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVA_CHILDREN),
+static WORD_EVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilable"),
         dictgen::InsensitiveStr::Ascii("lation"),
@@ -151424,12 +151424,12 @@ pub static WORD_EVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_EU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EU_CHILDREN),
+static WORD_EU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clidian"),
         dictgen::InsensitiveStr::Ascii("gencis"),
@@ -151505,12 +151505,12 @@ pub static WORD_EU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_ET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ET_CHILDREN),
+static WORD_ET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ET_CHILDREN),
     value: None,
 };
 
-pub static WORD_ET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ablish"),
         dictgen::InsensitiveStr::Ascii("ablishd"),
@@ -151622,12 +151622,12 @@ pub static WORD_ET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_ES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ES_CHILDREN),
+static WORD_ES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ES_CHILDREN),
     value: None,
 };
 
-static WORD_ES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ESA_NODE),
     None,
     Some(&WORD_ESC_NODE),
@@ -151656,23 +151656,23 @@ static WORD_ES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ESY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESY_CHILDREN),
+static WORD_ESY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESY_CHILDREN),
     value: Some(&["easy"]),
 };
 
-pub static WORD_ESY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ESU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESU_CHILDREN),
+static WORD_ESU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("do"),
         dictgen::InsensitiveStr::Ascii("mption"),
@@ -151681,12 +151681,12 @@ pub static WORD_ESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_EST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EST_CHILDREN),
+static WORD_EST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EST_CHILDREN),
     value: None,
 };
 
-pub static WORD_EST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abilish"),
         dictgen::InsensitiveStr::Ascii("abilshment"),
@@ -151762,12 +151762,12 @@ pub static WORD_EST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=10,
 };
 
-static WORD_ESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESS_CHILDREN),
+static WORD_ESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eintially"),
         dictgen::InsensitiveStr::Ascii("encial"),
@@ -151833,12 +151833,12 @@ pub static WORD_ESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ESP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESP_CHILDREN),
+static WORD_ESP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acally"),
         dictgen::InsensitiveStr::Ascii("ace"),
@@ -151918,23 +151918,23 @@ pub static WORD_ESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ESO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESO_CHILDREN),
+static WORD_ESO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("terisch")],
     values: &[&["esoteric"]],
     range: 7..=7,
 };
 
-static WORD_ESN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESN_CHILDREN),
+static WORD_ESN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ure"),
         dictgen::InsensitiveStr::Ascii("ured"),
@@ -151944,12 +151944,12 @@ pub static WORD_ESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_ESL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESL_CHILDREN),
+static WORD_ESL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ewhere"),
@@ -151958,12 +151958,12 @@ pub static WORD_ESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ESI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESI_CHILDREN),
+static WORD_ESI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -152009,12 +152009,12 @@ pub static WORD_ESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ESG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESG_CHILDREN),
+static WORD_ESG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -152026,12 +152026,12 @@ pub static WORD_ESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_ESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESE_CHILDREN),
+static WORD_ESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cute"),
         dictgen::InsensitiveStr::Ascii("ntial"),
@@ -152041,12 +152041,12 @@ pub static WORD_ESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_ESC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESC_CHILDREN),
+static WORD_ESC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alatie"),
         dictgen::InsensitiveStr::Ascii("alatin"),
@@ -152124,12 +152124,12 @@ pub static WORD_ESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESA_CHILDREN),
+static WORD_ESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cape"),
         dictgen::InsensitiveStr::Ascii("cpe"),
@@ -152140,12 +152140,12 @@ pub static WORD_ESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_ER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ER_CHILDREN),
+static WORD_ER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ER_CHILDREN),
     value: None,
 };
 
-static WORD_ER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ERA_NODE),
     None,
     None,
@@ -152174,12 +152174,12 @@ static WORD_ER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERV_CHILDREN),
+static WORD_ERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ery"),
         dictgen::InsensitiveStr::Ascii("erything"),
@@ -152189,12 +152189,12 @@ pub static WORD_ERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERT_CHILDREN),
+static WORD_ERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oneous"),
         dictgen::InsensitiveStr::Ascii("oneously"),
@@ -152210,12 +152210,12 @@ pub static WORD_ERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERR_CHILDREN),
+static WORD_ERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aneously"),
         dictgen::InsensitiveStr::Ascii("aticly"),
@@ -152287,23 +152287,23 @@ pub static WORD_ERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ERQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERQ_CHILDREN),
+static WORD_ERQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uest")],
     values: &[&["request"]],
     range: 4..=4,
 };
 
-static WORD_ERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERO_CHILDREN),
+static WORD_ERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("neous"),
         dictgen::InsensitiveStr::Ascii("niously"),
@@ -152327,12 +152327,12 @@ pub static WORD_ERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERM_CHILDREN),
+static WORD_ERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ergency"),
         dictgen::InsensitiveStr::Ascii("inated"),
@@ -152342,12 +152342,12 @@ pub static WORD_ERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_ERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERL_CHILDREN),
+static WORD_ERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iear"),
         dictgen::InsensitiveStr::Ascii("ier"),
@@ -152357,34 +152357,34 @@ pub static WORD_ERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_ERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERF_CHILDREN),
+static WORD_ERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ormance")],
     values: &[&["performance"]],
     range: 7..=7,
 };
 
-static WORD_ERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERE_CHILDREN),
+static WORD_ERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sted")],
     values: &[&["arrested", "erected"]],
     range: 4..=4,
 };
 
-static WORD_ERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERA_CHILDREN),
+static WORD_ERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ised"),
         dictgen::InsensitiveStr::Ascii("lier"),
@@ -152408,12 +152408,12 @@ pub static WORD_ERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_EQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EQ_CHILDREN),
+static WORD_EQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EQ_CHILDREN),
     value: None,
 };
 
-static WORD_EQ_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EQ_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EQA_NODE),
     None,
     None,
@@ -152442,12 +152442,12 @@ static WORD_EQ_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EQU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EQU_CHILDREN),
+static WORD_EQU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EQU_CHILDREN),
     value: None,
 };
 
-static WORD_EQU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EQU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EQUA_NODE),
     None,
     None,
@@ -152476,12 +152476,12 @@ static WORD_EQU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EQUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUV_CHILDREN),
+static WORD_EQUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alent"),
         dictgen::InsensitiveStr::Ascii("ilent"),
@@ -152491,23 +152491,23 @@ pub static WORD_EQUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_EQUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUU_CHILDREN),
+static WORD_EQUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ivalence")],
     values: &[&["equivalence"]],
     range: 8..=8,
 };
 
-static WORD_EQUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUT_CHILDREN),
+static WORD_EQUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -152516,23 +152516,23 @@ pub static WORD_EQUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EQUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUL_CHILDREN),
+static WORD_EQUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUL_CHILDREN),
     value: Some(&["equal"]),
 };
 
-pub static WORD_EQUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EQUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EQUI_CHILDREN),
+static WORD_EQUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EQUI_CHILDREN),
     value: None,
 };
 
-static WORD_EQUI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EQUI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EQUIA_NODE),
     None,
     None,
@@ -152561,12 +152561,12 @@ static WORD_EQUI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EQUIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIV_CHILDREN),
+static WORD_EQUIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alalent"),
         dictgen::InsensitiveStr::Ascii("alance"),
@@ -152646,34 +152646,34 @@ pub static WORD_EQUIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_EQUIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIT_CHILDREN),
+static WORD_EQUIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orial")],
     values: &[&["equatorial"]],
     range: 5..=5,
 };
 
-static WORD_EQUIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIR_CHILDREN),
+static WORD_EQUIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["require", "enquire", "equine", "esquire"]],
     range: 1..=1,
 };
 
-static WORD_EQUIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIP_CHILDREN),
+static WORD_EQUIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ement"),
@@ -152695,23 +152695,23 @@ pub static WORD_EQUIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_EQUIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIM_CHILDREN),
+static WORD_EQUIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ent")],
     values: &[&["equipment"]],
     range: 3..=3,
 };
 
-static WORD_EQUIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIL_CHILDREN),
+static WORD_EQUIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIL_CHILDREN),
     value: Some(&["equal"]),
 };
 
-pub static WORD_EQUIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avalent"),
         dictgen::InsensitiveStr::Ascii("avent"),
@@ -152747,23 +152747,23 @@ pub static WORD_EQUIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_EQUIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIE_CHILDREN),
+static WORD_EQUIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("valent")],
     values: &[&["equivalent"]],
     range: 6..=6,
 };
 
-static WORD_EQUIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIA_CHILDREN),
+static WORD_EQUIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lent"),
         dictgen::InsensitiveStr::Ascii("vlent"),
@@ -152772,12 +152772,12 @@ pub static WORD_EQUIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_EQUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUE_CHILDREN),
+static WORD_EQUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -152795,12 +152795,12 @@ pub static WORD_EQUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EQUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUA_CHILDREN),
+static WORD_EQUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilateral"),
         dictgen::InsensitiveStr::Ascii("ilty"),
@@ -152828,12 +152828,12 @@ pub static WORD_EQUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_EQI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQI_CHILDREN),
+static WORD_EQI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("valent"),
         dictgen::InsensitiveStr::Ascii("valents"),
@@ -152842,12 +152842,12 @@ pub static WORD_EQI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_EQA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQA_CHILDREN),
+static WORD_EQA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ul"),
         dictgen::InsensitiveStr::Ascii("ulity"),
@@ -152865,12 +152865,12 @@ pub static WORD_EQA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_EP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EP_CHILDREN),
+static WORD_EP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andable"),
         dictgen::InsensitiveStr::Ascii("ecifica"),
@@ -153002,12 +153002,12 @@ pub static WORD_EP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_EN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EN_CHILDREN),
+static WORD_EN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EN_CHILDREN),
     value: None,
 };
 
-static WORD_EN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENA_NODE),
     Some(&WORD_ENB_NODE),
     Some(&WORD_ENC_NODE),
@@ -153036,12 +153036,12 @@ static WORD_EN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENY_CHILDREN),
+static WORD_ENY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thing"),
         dictgen::InsensitiveStr::Ascii("way"),
@@ -153050,23 +153050,23 @@ pub static WORD_ENY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ENX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENX_CHILDREN),
+static WORD_ENX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENX_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["next"]],
     range: 1..=1,
 };
 
-static WORD_ENV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENV_CHILDREN),
+static WORD_ENV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENV_CHILDREN),
     value: None,
 };
 
-static WORD_ENV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENVA_NODE),
     None,
     None,
@@ -153095,23 +153095,23 @@ static WORD_ENV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENVV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVV_CHILDREN),
+static WORD_ENVV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ironment")],
     values: &[&["environment"]],
     range: 8..=8,
 };
 
-static WORD_ENVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVR_CHILDREN),
+static WORD_ENVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ionment"),
@@ -153143,12 +153143,12 @@ pub static WORD_ENVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_ENVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVO_CHILDREN),
+static WORD_ENVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ke"),
         dictgen::InsensitiveStr::Ascii("ked"),
@@ -153174,12 +153174,12 @@ pub static WORD_ENVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ENVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVL_CHILDREN),
+static WORD_ENVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eope"),
         dictgen::InsensitiveStr::Ascii("ope"),
@@ -153188,12 +153188,12 @@ pub static WORD_ENVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ENVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENVI_CHILDREN),
+static WORD_ENVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENVI_CHILDREN),
     value: None,
 };
 
-static WORD_ENVI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENVI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -153222,12 +153222,12 @@ static WORD_ENVI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENVIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVIR_CHILDREN),
+static WORD_ENVIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eonment"),
         dictgen::InsensitiveStr::Ascii("ionment"),
@@ -153329,12 +153329,12 @@ pub static WORD_ENVIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_ENVIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVIO_CHILDREN),
+static WORD_ENVIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mental"),
@@ -153398,12 +153398,12 @@ pub static WORD_ENVIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_ENVIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVIN_CHILDREN),
+static WORD_ENVIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("roment"),
         dictgen::InsensitiveStr::Ascii("ronment"),
@@ -153413,23 +153413,23 @@ pub static WORD_ENVIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_ENVID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVID_CHILDREN),
+static WORD_ENVID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVID_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enced")],
     values: &[&["evidenced"]],
     range: 5..=5,
 };
 
-static WORD_ENVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVE_CHILDREN),
+static WORD_ENVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("loppe"),
         dictgen::InsensitiveStr::Ascii("lopped"),
@@ -153449,23 +153449,23 @@ pub static WORD_ENVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ENVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVA_CHILDREN),
+static WORD_ENVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("luation")],
     values: &[&["evaluation"]],
     range: 7..=7,
 };
 
-static WORD_ENU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENU_CHILDREN),
+static WORD_ENU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("lation"),
@@ -153533,12 +153533,12 @@ pub static WORD_ENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENT_CHILDREN),
+static WORD_ENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENT_CHILDREN),
     value: None,
 };
 
-static WORD_ENT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENTA_NODE),
     Some(&WORD_ENTB_NODE),
     None,
@@ -153567,23 +153567,23 @@ static WORD_ENT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENTY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTY_CHILDREN),
+static WORD_ENTY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTY_CHILDREN),
     value: Some(&["entry", "entity"]),
 };
 
-pub static WORD_ENTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ENTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTU_CHILDREN),
+static WORD_ENTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("siastic"),
         dictgen::InsensitiveStr::Ascii("siastically"),
@@ -153592,12 +153592,12 @@ pub static WORD_ENTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=11,
 };
 
-static WORD_ENTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTT_CHILDREN),
+static WORD_ENTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ries"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -153606,12 +153606,12 @@ pub static WORD_ENTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ENTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTR_CHILDREN),
+static WORD_ENTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -153705,12 +153705,12 @@ pub static WORD_ENTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_ENTQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTQ_CHILDREN),
+static WORD_ENTQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uire"),
         dictgen::InsensitiveStr::Ascii("uired"),
@@ -153728,12 +153728,12 @@ pub static WORD_ENTQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ENTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTO_CHILDREN),
+static WORD_ENTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rpy"),
         dictgen::InsensitiveStr::Ascii("ties"),
@@ -153744,12 +153744,12 @@ pub static WORD_ENTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ENTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTI_CHILDREN),
+static WORD_ENTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erly"),
         dictgen::InsensitiveStr::Ascii("erty"),
@@ -153815,12 +153815,12 @@ pub static WORD_ENTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ENTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTH_CHILDREN),
+static WORD_ENTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aplies"),
         dictgen::InsensitiveStr::Ascii("aply"),
@@ -153900,12 +153900,12 @@ pub static WORD_ENTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_ENTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTE_CHILDREN),
+static WORD_ENTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("nded"),
@@ -153995,23 +153995,23 @@ pub static WORD_ENTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ENTB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTB_CHILDREN),
+static WORD_ENTB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ook")],
     values: &[&["netbook"]],
     range: 3..=3,
 };
 
-static WORD_ENTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTA_CHILDREN),
+static WORD_ENTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("glements"),
         dictgen::InsensitiveStr::Ascii("rtaining"),
@@ -154021,12 +154021,12 @@ pub static WORD_ENTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_ENS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENS_CHILDREN),
+static WORD_ENS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alve"),
         dictgen::InsensitiveStr::Ascii("alved"),
@@ -154046,12 +154046,12 @@ pub static WORD_ENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ENR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENR_CHILDREN),
+static WORD_ENR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gy"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -154083,12 +154083,12 @@ pub static WORD_ENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ENQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENQ_CHILDREN),
+static WORD_ENQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ue"),
         dictgen::InsensitiveStr::Ascii("ueing"),
@@ -154098,12 +154098,12 @@ pub static WORD_ENQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ENP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENP_CHILDREN),
+static WORD_ENP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("doint"),
         dictgen::InsensitiveStr::Ascii("doints"),
@@ -154121,12 +154121,12 @@ pub static WORD_ENP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENO_CHILDREN),
+static WORD_ENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cde"),
         dictgen::InsensitiveStr::Ascii("cded"),
@@ -154220,12 +154220,12 @@ pub static WORD_ENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENN_CHILDREN),
+static WORD_ENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emies"),
         dictgen::InsensitiveStr::Ascii("point"),
@@ -154236,12 +154236,12 @@ pub static WORD_ENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_ENM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENM_CHILDREN),
+static WORD_ENM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pty"),
         dictgen::InsensitiveStr::Ascii("um"),
@@ -154259,12 +154259,12 @@ pub static WORD_ENM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_ENL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENL_CHILDREN),
+static WORD_ENL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("argment"),
         dictgen::InsensitiveStr::Ascii("argments"),
@@ -154320,23 +154320,23 @@ pub static WORD_ENL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ENJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENJ_CHILDREN),
+static WORD_ENJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oing")],
     values: &[&["enjoying"]],
     range: 4..=4,
 };
 
-static WORD_ENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENI_CHILDREN),
+static WORD_ENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gneer"),
         dictgen::InsensitiveStr::Ascii("ronment"),
@@ -154372,12 +154372,12 @@ pub static WORD_ENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_ENH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENH_CHILDREN),
+static WORD_ENH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abce"),
         dictgen::InsensitiveStr::Ascii("abced"),
@@ -154439,12 +154439,12 @@ pub static WORD_ENH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ENG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENG_CHILDREN),
+static WORD_ENG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agaments"),
         dictgen::InsensitiveStr::Ascii("agemet"),
@@ -154530,12 +154530,12 @@ pub static WORD_ENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENF_CHILDREN),
+static WORD_ENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lamed"),
         dictgen::InsensitiveStr::Ascii("orcable"),
@@ -154569,12 +154569,12 @@ pub static WORD_ENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENE_CHILDREN),
+static WORD_ENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("abled"),
@@ -154646,12 +154646,12 @@ pub static WORD_ENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_END_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_END_CHILDREN),
+static WORD_END_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_END_CHILDREN),
     value: None,
 };
 
-static WORD_END_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_END_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENDA_NODE),
     None,
     Some(&WORD_ENDC_NODE),
@@ -154680,12 +154680,12 @@ static WORD_END_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDU_CHILDREN),
+static WORD_ENDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -154703,23 +154703,23 @@ pub static WORD_ENDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ENDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDR_CHILDREN),
+static WORD_ENDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ose")],
     values: &[&["endorse"]],
     range: 3..=3,
 };
 
-static WORD_ENDP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDP_CHILDREN),
+static WORD_ENDP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("doint"),
         dictgen::InsensitiveStr::Ascii("doints"),
@@ -154747,12 +154747,12 @@ pub static WORD_ENDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ENDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDO_CHILDREN),
+static WORD_ENDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctrinated"),
         dictgen::InsensitiveStr::Ascii("ctrination"),
@@ -154784,23 +154784,23 @@ pub static WORD_ENDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ENDN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDN_CHILDREN),
+static WORD_ENDN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oden")],
     values: &[&["endnode"]],
     range: 4..=4,
 };
 
-static WORD_ENDL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDL_CHILDREN),
+static WORD_ENDL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essley"),
         dictgen::InsensitiveStr::Ascii("essy"),
@@ -154809,12 +154809,12 @@ pub static WORD_ENDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ENDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDI_CHILDREN),
+static WORD_ENDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anes"),
         dictgen::InsensitiveStr::Ascii("aness"),
@@ -154846,34 +154846,34 @@ pub static WORD_ENDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ENDG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDG_CHILDREN),
+static WORD_ENDG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["edge", "end"]],
     range: 1..=1,
 };
 
-static WORD_ENDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDF_CHILDREN),
+static WORD_ENDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("i")],
     values: &[&["endif"]],
     range: 1..=1,
 };
 
-static WORD_ENDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDE_CHILDREN),
+static WORD_ENDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDE_CHILDREN),
     value: Some(&["end"]),
 };
 
-pub static WORD_ENDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ver"),
         dictgen::InsensitiveStr::Ascii("vered"),
@@ -154897,23 +154897,23 @@ pub static WORD_ENDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ENDD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDD_CHILDREN),
+static WORD_ENDD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["ending"]],
     range: 3..=3,
 };
 
-static WORD_ENDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDC_CHILDREN),
+static WORD_ENDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oded"),
         dictgen::InsensitiveStr::Ascii("oder"),
@@ -154933,12 +154933,12 @@ pub static WORD_ENDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ENDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDA_CHILDREN),
+static WORD_ENDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gnering"),
         dictgen::InsensitiveStr::Ascii("ndering"),
@@ -154954,12 +154954,12 @@ pub static WORD_ENDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENC_CHILDREN),
+static WORD_ENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENC_CHILDREN),
     value: None,
 };
 
-static WORD_ENC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENCA_NODE),
     None,
     None,
@@ -154988,12 +154988,12 @@ static WORD_ENC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENCY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCY_CHILDREN),
+static WORD_ENCY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clapedia"),
         dictgen::InsensitiveStr::Ascii("clepedia"),
@@ -155041,12 +155041,12 @@ pub static WORD_ENCY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ENCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCU_CHILDREN),
+static WORD_ENCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mberance"),
         dictgen::InsensitiveStr::Ascii("psulates"),
@@ -155055,12 +155055,12 @@ pub static WORD_ENCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=8,
 };
 
-static WORD_ENCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCR_CHILDREN),
+static WORD_ENCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cypt"),
         dictgen::InsensitiveStr::Ascii("cypted"),
@@ -155140,23 +155140,23 @@ pub static WORD_ENCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ENCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCP_CHILDREN),
+static WORD_ENCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rytion")],
     values: &[&["encryption"]],
     range: 6..=6,
 };
 
-static WORD_ENCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENCO_CHILDREN),
+static WORD_ENCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENCO_CHILDREN),
     value: None,
 };
 
-static WORD_ENCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_ENCOC_NODE),
@@ -155185,12 +155185,12 @@ static WORD_ENCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENCOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOU_CHILDREN),
+static WORD_ENCOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nted"),
         dictgen::InsensitiveStr::Ascii("nteerd"),
@@ -155244,12 +155244,12 @@ pub static WORD_ENCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ENCOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOS_CHILDREN),
+static WORD_ENCOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -155273,12 +155273,12 @@ pub static WORD_ENCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ENCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOR_CHILDREN),
+static WORD_ENCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -155306,12 +155306,12 @@ pub static WORD_ENCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ENCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCON_CHILDREN),
+static WORD_ENCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -155333,12 +155333,12 @@ pub static WORD_ENCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ENCOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOM_CHILDREN),
+static WORD_ENCOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apsses"),
         dictgen::InsensitiveStr::Ascii("pas"),
@@ -155370,12 +155370,12 @@ pub static WORD_ENCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ENCOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOL_CHILDREN),
+static WORD_ENCOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sed"),
         dictgen::InsensitiveStr::Ascii("sure"),
@@ -155384,12 +155384,12 @@ pub static WORD_ENCOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ENCOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOD_CHILDREN),
+static WORD_ENCOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ingt"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -155400,12 +155400,12 @@ pub static WORD_ENCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ENCOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOC_CHILDREN),
+static WORD_ENCOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -155427,12 +155427,12 @@ pub static WORD_ENCOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ENCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCL_CHILDREN),
+static WORD_ENCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("osng"),
         dictgen::InsensitiveStr::Ascii("osue"),
@@ -155456,23 +155456,23 @@ pub static WORD_ENCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ENCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCI_CHILDREN),
+static WORD_ENCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("clopedia")],
     values: &[&["encyclopedia"]],
     range: 8..=8,
 };
 
-static WORD_ENCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCH_CHILDREN),
+static WORD_ENCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amtment"),
         dictgen::InsensitiveStr::Ascii("anced"),
@@ -155522,23 +155522,23 @@ pub static WORD_ENCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_ENCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCE_CHILDREN),
+static WORD_ENCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("clopedia")],
     values: &[&["encyclopedia"]],
     range: 8..=8,
 };
 
-static WORD_ENCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCA_CHILDREN),
+static WORD_ENCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hnt"),
         dictgen::InsensitiveStr::Ascii("hnting"),
@@ -155578,12 +155578,12 @@ pub static WORD_ENCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ENB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENB_CHILDREN),
+static WORD_ENB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("abled"),
@@ -155619,12 +155619,12 @@ pub static WORD_ENB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENA_CHILDREN),
+static WORD_ENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -155668,12 +155668,12 @@ pub static WORD_ENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_EM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EM_CHILDREN),
+static WORD_EM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EM_CHILDREN),
     value: None,
 };
 
-static WORD_EM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EMA_NODE),
     Some(&WORD_EMB_NODE),
     Some(&WORD_EMC_NODE),
@@ -155702,12 +155702,12 @@ static WORD_EM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMU_CHILDREN),
+static WORD_EMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("altion"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -155729,12 +155729,12 @@ pub static WORD_EMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_EMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMT_CHILDREN),
+static WORD_EMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -155760,12 +155760,12 @@ pub static WORD_EMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_EMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EMP_CHILDREN),
+static WORD_EMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EMP_CHILDREN),
     value: None,
 };
 
-static WORD_EMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EMPA_NODE),
     None,
     None,
@@ -155794,34 +155794,34 @@ static WORD_EMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EMPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPY_CHILDREN),
+static WORD_EMPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPY_CHILDREN),
     value: Some(&["empty"]),
 };
 
-pub static WORD_EMPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ty")],
     values: &[&["empty"]],
     range: 2..=2,
 };
 
-static WORD_EMPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPU_CHILDREN),
+static WORD_EMPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["empty"]],
     range: 1..=1,
 };
 
-static WORD_EMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPT_CHILDREN),
+static WORD_EMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("niess"),
@@ -155841,12 +155841,12 @@ pub static WORD_EMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPR_CHILDREN),
+static WORD_EMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essed"),
         dictgen::InsensitiveStr::Ascii("essing"),
@@ -155882,12 +155882,12 @@ pub static WORD_EMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_EMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPO_CHILDREN),
+static WORD_EMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lyees"),
         dictgen::InsensitiveStr::Ascii("rer"),
@@ -155896,12 +155896,12 @@ pub static WORD_EMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_EMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPL_CHILDREN),
+static WORD_EMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ore"),
         dictgen::InsensitiveStr::Ascii("oyeed"),
@@ -155941,12 +155941,12 @@ pub static WORD_EMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPI_CHILDREN),
+static WORD_EMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("racally"),
@@ -155970,12 +155970,12 @@ pub static WORD_EMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EMPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPH_CHILDREN),
+static WORD_EMPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acized"),
         dictgen::InsensitiveStr::Ascii("acizing"),
@@ -156031,12 +156031,12 @@ pub static WORD_EMPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_EMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPE_CHILDREN),
+static WORD_EMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rial"),
         dictgen::InsensitiveStr::Ascii("rially"),
@@ -156052,12 +156052,12 @@ pub static WORD_EMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_EMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPA_CHILDREN),
+static WORD_EMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hsize"),
         dictgen::InsensitiveStr::Ascii("hsized"),
@@ -156085,12 +156085,12 @@ pub static WORD_EMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMO_CHILDREN),
+static WORD_EMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bdiment"),
         dictgen::InsensitiveStr::Ascii("difying"),
@@ -156116,23 +156116,23 @@ pub static WORD_EMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMN_CHILDREN),
+static WORD_EMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ity")],
     values: &[&["enmity"]],
     range: 3..=3,
 };
 
-static WORD_EMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMM_CHILDREN),
+static WORD_EMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bedding"),
         dictgen::InsensitiveStr::Ascii("ediately"),
@@ -156176,23 +156176,23 @@ pub static WORD_EMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EML_CHILDREN),
+static WORD_EML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EML_CHILDREN),
     value: None,
 };
 
-pub static WORD_EML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["emulation"]],
     range: 5..=5,
 };
 
-static WORD_EMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMI_CHILDREN),
+static WORD_EMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ited"),
@@ -156228,12 +156228,12 @@ pub static WORD_EMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_EME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EME_CHILDREN),
+static WORD_EME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EME_CHILDREN),
     value: None,
 };
 
-pub static WORD_EME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dded"),
         dictgen::InsensitiveStr::Ascii("grency"),
@@ -156267,12 +156267,12 @@ pub static WORD_EME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_EMC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMC_CHILDREN),
+static WORD_EMC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("ompass"),
@@ -156288,12 +156288,12 @@ pub static WORD_EMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_EMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EMB_CHILDREN),
+static WORD_EMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EMB_CHILDREN),
     value: None,
 };
 
-static WORD_EMB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EMB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EMBA_NODE),
     Some(&WORD_EMBB_NODE),
     None,
@@ -156322,12 +156322,12 @@ static WORD_EMB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EMBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBR_CHILDREN),
+static WORD_EMBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ago"),
         dictgen::InsensitiveStr::Ascii("io"),
@@ -156338,12 +156338,12 @@ pub static WORD_EMBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EMBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBO_CHILDREN),
+static WORD_EMBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dyment"),
         dictgen::InsensitiveStr::Ascii("ld"),
@@ -156352,23 +156352,23 @@ pub static WORD_EMBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EMBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBL_CHILDREN),
+static WORD_EMBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("amatic")],
     values: &[&["emblematic"]],
     range: 6..=6,
 };
 
-static WORD_EMBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBE_CHILDREN),
+static WORD_EMBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bbed"),
         dictgen::InsensitiveStr::Ascii("dd"),
@@ -156406,12 +156406,12 @@ pub static WORD_EMBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EMBD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBD_CHILDREN),
+static WORD_EMBD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("edded"),
@@ -156420,12 +156420,12 @@ pub static WORD_EMBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_EMBB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBB_CHILDREN),
+static WORD_EMBB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edded"),
         dictgen::InsensitiveStr::Ascii("edding"),
@@ -156441,12 +156441,12 @@ pub static WORD_EMBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_EMBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBA_CHILDREN),
+static WORD_EMBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lance"),
         dictgen::InsensitiveStr::Ascii("raasing"),
@@ -156536,12 +156536,12 @@ pub static WORD_EMBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_EMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMA_CHILDREN),
+static WORD_EMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baroged"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -156581,12 +156581,12 @@ pub static WORD_EMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_EL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EL_CHILDREN),
+static WORD_EL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EL_CHILDREN),
     value: None,
 };
 
-static WORD_EL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ELA_NODE),
     None,
     Some(&WORD_ELC_NODE),
@@ -156615,12 +156615,12 @@ static WORD_EL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ELS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELS_CHILDREN),
+static WORD_ELS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ef"),
         dictgen::InsensitiveStr::Ascii("ehwere"),
@@ -156648,23 +156648,23 @@ pub static WORD_ELS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ELP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELP_CHILDREN),
+static WORD_ELP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hant")],
     values: &[&["elephant"]],
     range: 4..=4,
 };
 
-static WORD_ELO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELO_CHILDREN),
+static WORD_ELO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctrolytes"),
         dictgen::InsensitiveStr::Ascii("quantly"),
@@ -156682,12 +156682,12 @@ pub static WORD_ELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_ELM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELM_CHILDREN),
+static WORD_ELM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enet"),
         dictgen::InsensitiveStr::Ascii("enets"),
@@ -156711,12 +156711,12 @@ pub static WORD_ELM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_ELL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELL_CHILDREN),
+static WORD_ELL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apsed"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -156780,12 +156780,12 @@ pub static WORD_ELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ELI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELI_CHILDREN),
+static WORD_ELI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cided"),
         dictgen::InsensitiveStr::Ascii("gable"),
@@ -156873,23 +156873,23 @@ pub static WORD_ELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ELG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELG_CHILDREN),
+static WORD_ELG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ible")],
     values: &[&["eligible"]],
     range: 4..=4,
 };
 
-static WORD_ELE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ELE_CHILDREN),
+static WORD_ELE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ELE_CHILDREN),
     value: None,
 };
 
-static WORD_ELE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ELE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ELEA_NODE),
     None,
     Some(&WORD_ELEC_NODE),
@@ -156918,23 +156918,23 @@ static WORD_ELE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ELEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEV_CHILDREN),
+static WORD_ELEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atin")],
     values: &[&["elevation"]],
     range: 4..=4,
 };
 
-static WORD_ELET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELET_CHILDREN),
+static WORD_ELET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELET_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ricity"),
         dictgen::InsensitiveStr::Ascii("romagnitic"),
@@ -156950,23 +156950,23 @@ pub static WORD_ELET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_ELES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELES_CHILDREN),
+static WORD_ELES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELES_CHILDREN),
     value: Some(&["eels", "else"]),
 };
 
-pub static WORD_ELES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["else"]],
     range: 1..=1,
 };
 
-static WORD_ELEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEP_CHILDREN),
+static WORD_ELEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahnts"),
         dictgen::InsensitiveStr::Ascii("hans"),
@@ -156986,23 +156986,23 @@ pub static WORD_ELEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ELEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEN_CHILDREN),
+static WORD_ELEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ment")],
     values: &[&["element"]],
     range: 4..=4,
 };
 
-static WORD_ELEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEM_CHILDREN),
+static WORD_ELEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("antary"),
@@ -157088,12 +157088,12 @@ pub static WORD_ELEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ELEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEL_CHILDREN),
+static WORD_ELEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ements"),
@@ -157113,23 +157113,23 @@ pub static WORD_ELEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ELEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEK_CHILDREN),
+static WORD_ELEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("trolytes")],
     values: &[&["electrolytes"]],
     range: 8..=8,
 };
 
-static WORD_ELEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEG_CHILDREN),
+static WORD_ELEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ently"),
         dictgen::InsensitiveStr::Ascii("ible"),
@@ -157138,12 +157138,12 @@ pub static WORD_ELEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_ELEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEE_CHILDREN),
+static WORD_ELEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mnt"),
         dictgen::InsensitiveStr::Ascii("mnts"),
@@ -157153,12 +157153,12 @@ pub static WORD_ELEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ELEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ELEC_CHILDREN),
+static WORD_ELEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ELEC_CHILDREN),
     value: None,
 };
 
-static WORD_ELEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ELEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -157187,12 +157187,12 @@ static WORD_ELEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ELECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ELECT_CHILDREN),
+static WORD_ELECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ELECT_CHILDREN),
     value: None,
 };
 
-static WORD_ELECT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ELECT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -157221,12 +157221,12 @@ static WORD_ELECT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ELECTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECTR_CHILDREN),
+static WORD_ELECTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("icain"),
@@ -157336,12 +157336,12 @@ pub static WORD_ELECTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_ELECTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECTO_CHILDREN),
+static WORD_ELECTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nic"),
@@ -157375,12 +157375,12 @@ pub static WORD_ELECTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_ELECTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECTI_CHILDREN),
+static WORD_ELECTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cal"),
@@ -157400,23 +157400,23 @@ pub static WORD_ELECTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_ELECTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECTH_CHILDREN),
+static WORD_ELECTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("or")],
     values: &[&["electro"]],
     range: 2..=2,
 };
 
-static WORD_ELECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECR_CHILDREN),
+static WORD_ELECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icity"),
         dictgen::InsensitiveStr::Ascii("to"),
@@ -157432,12 +157432,12 @@ pub static WORD_ELECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_ELEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEA_CHILDREN),
+static WORD_ELEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("sed"),
@@ -157448,23 +157448,23 @@ pub static WORD_ELEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_ELD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELD_CHILDREN),
+static WORD_ELD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("istribution")],
     values: &[&["redistribution"]],
     range: 11..=11,
 };
 
-static WORD_ELC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELC_CHILDREN),
+static WORD_ELC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipse"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -157474,12 +157474,12 @@ pub static WORD_ELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_ELA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELA_CHILDREN),
+static WORD_ELA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gance"),
         dictgen::InsensitiveStr::Ascii("gant"),
@@ -157511,12 +157511,12 @@ pub static WORD_ELA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_EJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EJ_CHILDREN),
+static WORD_EJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_EJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acluation"),
         dictgen::InsensitiveStr::Ascii("acualte"),
@@ -157542,12 +157542,12 @@ pub static WORD_EJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=10,
 };
 
-static WORD_EI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EI_CHILDREN),
+static WORD_EI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egn"),
         dictgen::InsensitiveStr::Ascii("fnach"),
@@ -157597,12 +157597,12 @@ pub static WORD_EI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_EH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EH_CHILDREN),
+static WORD_EH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("anced"),
@@ -157646,12 +157646,12 @@ pub static WORD_EH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_EG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EG_CHILDREN),
+static WORD_EG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aletarian"),
@@ -157727,12 +157727,12 @@ pub static WORD_EG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_EF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EF_CHILDREN),
+static WORD_EF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EF_CHILDREN),
     value: None,
 };
 
-static WORD_EF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -157761,12 +157761,12 @@ static WORD_EF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFO_CHILDREN),
+static WORD_EFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rceable"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -157775,12 +157775,12 @@ pub static WORD_EFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_EFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFI_CHILDREN),
+static WORD_EFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cient"),
         dictgen::InsensitiveStr::Ascii("nitions"),
@@ -157789,12 +157789,12 @@ pub static WORD_EFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_EFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EFF_CHILDREN),
+static WORD_EFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EFF_CHILDREN),
     value: None,
 };
 
-static WORD_EFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EFF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EFFC_NODE),
@@ -157823,23 +157823,23 @@ static WORD_EFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EFFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFU_CHILDREN),
+static WORD_EFFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lence")],
     values: &[&["effluence"]],
     range: 5..=5,
 };
 
-static WORD_EFFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFO_CHILDREN),
+static WORD_EFFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rdlessly"),
@@ -157861,12 +157861,12 @@ pub static WORD_EFFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EFFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFI_CHILDREN),
+static WORD_EFFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccient"),
         dictgen::InsensitiveStr::Ascii("ceincy"),
@@ -157922,12 +157922,12 @@ pub static WORD_EFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_EFFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFE_CHILDREN),
+static WORD_EFFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceively"),
         dictgen::InsensitiveStr::Ascii("ciency"),
@@ -157993,12 +157993,12 @@ pub static WORD_EFFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_EFFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFC_CHILDREN),
+static WORD_EFFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iency"),
         dictgen::InsensitiveStr::Ascii("ient"),
@@ -158016,12 +158016,12 @@ pub static WORD_EFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_EFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFE_CHILDREN),
+static WORD_EFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -158041,12 +158041,12 @@ pub static WORD_EFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_EE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EE_CHILDREN),
+static WORD_EE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arly"),
         dictgen::InsensitiveStr::Ascii("cutable"),
@@ -158088,12 +158088,12 @@ pub static WORD_EE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ED_CHILDREN),
+static WORD_ED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ED_CHILDREN),
     value: None,
 };
 
-pub static WORD_ED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biles"),
         dictgen::InsensitiveStr::Ascii("cdic"),
@@ -158187,12 +158187,12 @@ pub static WORD_ED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_EC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EC_CHILDREN),
+static WORD_EC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ape"),
         dictgen::InsensitiveStr::Ascii("ause"),
@@ -158326,12 +158326,12 @@ pub static WORD_EC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_EB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EB_CHILDREN),
+static WORD_EB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -158351,12 +158351,12 @@ pub static WORD_EB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_EA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EA_CHILDREN),
+static WORD_EA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EA_CHILDREN),
     value: None,
 };
 
-static WORD_EA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_EAB_NODE),
     Some(&WORD_EAC_NODE),
@@ -158385,12 +158385,12 @@ static WORD_EA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_EAZ_NODE),
 ];
 
-static WORD_EAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAZ_CHILDREN),
+static WORD_EAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ier"),
         dictgen::InsensitiveStr::Ascii("iest"),
@@ -158400,34 +158400,34 @@ pub static WORD_EAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_EAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAX_CHILDREN),
+static WORD_EAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ct")],
     values: &[&["exact"]],
     range: 2..=2,
 };
 
-static WORD_EAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAU_CHILDREN),
+static WORD_EAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ality")],
     values: &[&["equality"]],
     range: 5..=5,
 };
 
-static WORD_EAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAT_CHILDREN),
+static WORD_EAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("her"),
         dictgen::InsensitiveStr::Ascii("swood"),
@@ -158443,12 +158443,12 @@ pub static WORD_EAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_EAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAS_CHILDREN),
+static WORD_EAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ely"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -158492,12 +158492,12 @@ pub static WORD_EAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_EAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAR_CHILDREN),
+static WORD_EAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("htbound"),
@@ -158565,12 +158565,12 @@ pub static WORD_EAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_EAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAN_CHILDREN),
+static WORD_EAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -158580,12 +158580,12 @@ pub static WORD_EAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_EAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAM_CHILDREN),
+static WORD_EAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cs"),
         dictgen::InsensitiveStr::Ascii("il"),
@@ -158596,12 +158596,12 @@ pub static WORD_EAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_EAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAL_CHILDREN),
+static WORD_EAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ier"),
         dictgen::InsensitiveStr::Ascii("iest"),
@@ -158612,12 +158612,12 @@ pub static WORD_EAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_EAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAI_CHILDREN),
+static WORD_EAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lier"),
         dictgen::InsensitiveStr::Ascii("ser"),
@@ -158627,34 +158627,34 @@ pub static WORD_EAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_EAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAH_CHILDREN),
+static WORD_EAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("c")],
     values: &[&["each"]],
     range: 1..=1,
 };
 
-static WORD_EAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAG_CHILDREN),
+static WORD_EAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rely")],
     values: &[&["eagerly"]],
     range: 4..=4,
 };
 
-static WORD_EAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAC_CHILDREN),
+static WORD_EAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -158676,23 +158676,23 @@ pub static WORD_EAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_EAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAB_CHILDREN),
+static WORD_EAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("led")],
     values: &[&["enabled"]],
     range: 3..=3,
 };
 
-static WORD_D_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_D_CHILDREN),
+static WORD_D_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_D_CHILDREN),
     value: None,
 };
 
-static WORD_D_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_D_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DA_NODE),
     Some(&WORD_DB_NODE),
     Some(&WORD_DC_NODE),
@@ -158721,12 +158721,12 @@ static WORD_D_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DY_CHILDREN),
+static WORD_DY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amically"),
         dictgen::InsensitiveStr::Ascii("anamically"),
@@ -158860,34 +158860,34 @@ pub static WORD_DY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_DW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DW_CHILDREN),
+static WORD_DW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arvens")],
     values: &[&["dwarves"]],
     range: 6..=6,
 };
 
-static WORD_DV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DV_CHILDREN),
+static WORD_DV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ided")],
     values: &[&["divided"]],
     range: 4..=4,
 };
 
-static WORD_DU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DU_CHILDREN),
+static WORD_DU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DU_CHILDREN),
     value: None,
 };
 
-static WORD_DU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DUA_NODE),
     Some(&WORD_DUB_NODE),
     Some(&WORD_DUC_NODE),
@@ -158916,23 +158916,23 @@ static WORD_DU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUT_CHILDREN),
+static WORD_DUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["during"]],
     range: 3..=3,
 };
 
-static WORD_DUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUS_CHILDREN),
+static WORD_DUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("btep"),
         dictgen::InsensitiveStr::Ascii("functional"),
@@ -158948,12 +158948,12 @@ pub static WORD_DUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_DUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUR_CHILDREN),
+static WORD_DUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abiliy"),
         dictgen::InsensitiveStr::Ascii("abillity"),
@@ -158995,12 +158995,12 @@ pub static WORD_DUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_DUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUP_CHILDREN),
+static WORD_DUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icate"),
         dictgen::InsensitiveStr::Ascii("ilcates"),
@@ -159124,23 +159124,23 @@ pub static WORD_DUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_DUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUO_CHILDREN),
+static WORD_DUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("blequote")],
     values: &[&["doublequote"]],
     range: 8..=8,
 };
 
-static WORD_DUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUN_CHILDREN),
+static WORD_DUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egon"),
         dictgen::InsensitiveStr::Ascii("egons"),
@@ -159162,12 +159162,12 @@ pub static WORD_DUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_DUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUM_CHILDREN),
+static WORD_DUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUM_CHILDREN),
     value: Some(&["dumb"]),
 };
 
-pub static WORD_DUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bbellls"),
         dictgen::InsensitiveStr::Ascii("bbels"),
@@ -159201,12 +159201,12 @@ pub static WORD_DUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_DUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUL_CHILDREN),
+static WORD_DUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aity"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -159216,12 +159216,12 @@ pub static WORD_DUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_DUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUI_CHILDREN),
+static WORD_DUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("rng"),
@@ -159230,12 +159230,12 @@ pub static WORD_DUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_DUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUE_CHILDREN),
+static WORD_DUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -159249,23 +159249,23 @@ pub static WORD_DUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_DUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUD_CHILDREN),
+static WORD_DUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("o")],
     values: &[&["sudo"]],
     range: 1..=1,
 };
 
-static WORD_DUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUC_CHILDREN),
+static WORD_DUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("ument"),
@@ -159274,12 +159274,12 @@ pub static WORD_DUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_DUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUB_CHILDREN),
+static WORD_DUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ios"),
         dictgen::InsensitiveStr::Ascii("le"),
@@ -159317,12 +159317,12 @@ pub static WORD_DUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUA_CHILDREN),
+static WORD_DUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghter"),
         dictgen::InsensitiveStr::Ascii("ghters"),
@@ -159333,12 +159333,12 @@ pub static WORD_DUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_DT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DT_CHILDREN),
+static WORD_DT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erminated"),
         dictgen::InsensitiveStr::Ascii("he"),
@@ -159348,12 +159348,12 @@ pub static WORD_DT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DS_CHILDREN),
+static WORD_DS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crete"),
         dictgen::InsensitiveStr::Ascii("cretion"),
@@ -159387,12 +159387,12 @@ pub static WORD_DS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_DR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DR_CHILDREN),
+static WORD_DR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DR_CHILDREN),
     value: None,
 };
 
-static WORD_DR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DRA_NODE),
     None,
     None,
@@ -159421,12 +159421,12 @@ static WORD_DR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRW_CHILDREN),
+static WORD_DRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("awing"),
@@ -159436,23 +159436,23 @@ pub static WORD_DRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_DRV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRV_CHILDREN),
+static WORD_DRV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ier")],
     values: &[&["driver"]],
     range: 3..=3,
 };
 
-static WORD_DRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRU_CHILDREN),
+static WORD_DRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ming"),
@@ -159463,12 +159463,12 @@ pub static WORD_DRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_DRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRO_CHILDREN),
+static WORD_DRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("pabel"),
@@ -159502,23 +159502,23 @@ pub static WORD_DRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_DRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRN_CHILDREN),
+static WORD_DRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ik")],
     values: &[&["drink"]],
     range: 2..=2,
 };
 
-static WORD_DRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRI_CHILDREN),
+static WORD_DRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agram"),
         dictgen::InsensitiveStr::Ascii("agrammed"),
@@ -159564,23 +159564,23 @@ pub static WORD_DRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRF_CHILDREN),
+static WORD_DRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iting")],
     values: &[&["drifting"]],
     range: 5..=5,
 };
 
-static WORD_DRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRE_CHILDREN),
+static WORD_DRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asm"),
         dictgen::InsensitiveStr::Ascii("awn"),
@@ -159606,12 +159606,12 @@ pub static WORD_DRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_DRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRA_CHILDREN),
+static WORD_DRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clua"),
         dictgen::InsensitiveStr::Ascii("conain"),
@@ -159685,12 +159685,12 @@ pub static WORD_DRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_DP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DP_CHILDREN),
+static WORD_DP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eends"),
         dictgen::InsensitiveStr::Ascii("endent"),
@@ -159701,12 +159701,12 @@ pub static WORD_DP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_DO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DO_CHILDREN),
+static WORD_DO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DO_CHILDREN),
     value: None,
 };
 
-static WORD_DO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DOA_NODE),
     Some(&WORD_DOB_NODE),
     Some(&WORD_DOC_NODE),
@@ -159735,34 +159735,34 @@ static WORD_DO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOY_CHILDREN),
+static WORD_DOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gen")],
     values: &[&["doxygen"]],
     range: 3..=3,
 };
 
-static WORD_DOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOX_CHILDREN),
+static WORD_DOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gen")],
     values: &[&["doxygen"]],
     range: 3..=3,
 };
 
-static WORD_DOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DOW_CHILDREN),
+static WORD_DOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DOW_CHILDREN),
     value: None,
 };
 
-static WORD_DOW_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DOW_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -159791,34 +159791,34 @@ static WORD_DOW_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOWT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWT_CHILDREN),
+static WORD_DOWT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWT_CHILDREN),
     value: Some(&["doubt"]),
 };
 
-pub static WORD_DOWT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DOWS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWS_CHILDREN),
+static WORD_DOWS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWS_CHILDREN),
     value: Some(&["does"]),
 };
 
-pub static WORD_DOWS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DOWR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWR_CHILDREN),
+static WORD_DOWR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -159827,12 +159827,12 @@ pub static WORD_DOWR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_DOWN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DOWN_CHILDREN),
+static WORD_DOWN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DOWN_CHILDREN),
     value: None,
 };
 
-static WORD_DOWN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DOWN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DOWNA_NODE),
     None,
     Some(&WORD_DOWNC_NODE),
@@ -159861,12 +159861,12 @@ static WORD_DOWN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOWNW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNW_CHILDREN),
+static WORD_DOWNW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oters"),
         dictgen::InsensitiveStr::Ascii("oting"),
@@ -159875,12 +159875,12 @@ pub static WORD_DOWNW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_DOWNV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNV_CHILDREN),
+static WORD_DOWNV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iting"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -159934,12 +159934,12 @@ pub static WORD_DOWNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DOWNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNT_CHILDREN),
+static WORD_DOWNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("okers"),
         dictgen::InsensitiveStr::Ascii("oking"),
@@ -159949,12 +159949,12 @@ pub static WORD_DOWNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_DOWNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNS_CHILDREN),
+static WORD_DOWNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iders"),
         dictgen::InsensitiveStr::Ascii("tar"),
@@ -159986,12 +159986,12 @@ pub static WORD_DOWNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DOWNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNR_CHILDREN),
+static WORD_DOWNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -160017,12 +160017,12 @@ pub static WORD_DOWNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DOWNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNO_CHILDREN),
+static WORD_DOWNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -160050,12 +160050,12 @@ pub static WORD_DOWNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DOWNL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNL_CHILDREN),
+static WORD_DOWNL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -160121,12 +160121,12 @@ pub static WORD_DOWNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DOWNG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNG_CHILDREN),
+static WORD_DOWNG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -160186,23 +160186,23 @@ pub static WORD_DOWNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DOWNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNC_CHILDREN),
+static WORD_DOWNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ale")],
     values: &[&["downscale"]],
     range: 3..=3,
 };
 
-static WORD_DOWNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNA_CHILDREN),
+static WORD_DOWNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("grade"),
         dictgen::InsensitiveStr::Ascii("graded"),
@@ -160218,12 +160218,12 @@ pub static WORD_DOWNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DOWL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWL_CHILDREN),
+static WORD_DOWL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ink"),
         dictgen::InsensitiveStr::Ascii("inks"),
@@ -160247,23 +160247,23 @@ pub static WORD_DOWL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DOWG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWG_CHILDREN),
+static WORD_DOWG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rade")],
     values: &[&["downgrade"]],
     range: 4..=4,
 };
 
-static WORD_DOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOU_CHILDREN),
+static WORD_DOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -160353,12 +160353,12 @@ pub static WORD_DOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_DOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOT_CHILDREN),
+static WORD_DOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("rmund"),
@@ -160367,12 +160367,12 @@ pub static WORD_DOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_DOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOS_CHILDREN),
+static WORD_DOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("closed"),
         dictgen::InsensitiveStr::Ascii("closes"),
@@ -160410,12 +160410,12 @@ pub static WORD_DOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOR_CHILDREN),
+static WORD_DOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -160443,12 +160443,12 @@ pub static WORD_DOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_DOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOP_CHILDREN),
+static WORD_DOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lhin"),
         dictgen::InsensitiveStr::Ascii("lhins"),
@@ -160459,12 +160459,12 @@ pub static WORD_DOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_DOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOO_CHILDREN),
+static WORD_DOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cument"),
         dictgen::InsensitiveStr::Ascii("cumentaries"),
@@ -160496,12 +160496,12 @@ pub static WORD_DOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_DON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DON_CHILDREN),
+static WORD_DON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DON_CHILDREN),
     value: None,
 };
 
-pub static WORD_DON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ains"),
@@ -160551,12 +160551,12 @@ pub static WORD_DON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_DOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOM_CHILDREN),
+static WORD_DOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainate"),
         dictgen::InsensitiveStr::Ascii("ait"),
@@ -160648,12 +160648,12 @@ pub static WORD_DOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_DOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOL_CHILDREN),
+static WORD_DOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hpin"),
         dictgen::InsensitiveStr::Ascii("hpins"),
@@ -160679,12 +160679,12 @@ pub static WORD_DOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_DOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOK_CHILDREN),
+static WORD_DOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -160710,12 +160710,12 @@ pub static WORD_DOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_DOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOI_CHILDREN),
+static WORD_DOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -160733,12 +160733,12 @@ pub static WORD_DOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_DOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOG_CHILDREN),
+static WORD_DOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amtic"),
         dictgen::InsensitiveStr::Ascii("dammit"),
@@ -160758,12 +160758,12 @@ pub static WORD_DOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_DOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOE_CHILDREN),
+static WORD_DOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -160783,12 +160783,12 @@ pub static WORD_DOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_DOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DOC_CHILDREN),
+static WORD_DOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DOC_CHILDREN),
     value: None,
 };
 
-static WORD_DOC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DOC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DOCC_NODE),
@@ -160817,12 +160817,12 @@ static WORD_DOC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DOCU_CHILDREN),
+static WORD_DOCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DOCU_CHILDREN),
     value: None,
 };
 
-static WORD_DOCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DOCU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DOCUC_NODE),
@@ -160851,23 +160851,23 @@ static WORD_DOCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOCUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUN_CHILDREN),
+static WORD_DOCUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ment")],
     values: &[&["document"]],
     range: 4..=4,
 };
 
-static WORD_DOCUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUM_CHILDREN),
+static WORD_DOCUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("antaries"),
@@ -160991,12 +160991,12 @@ pub static WORD_DOCUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_DOCUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUH_CHILDREN),
+static WORD_DOCUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebag"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -161006,12 +161006,12 @@ pub static WORD_DOCUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_DOCUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUE_CHILDREN),
+static WORD_DOCUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("ments"),
@@ -161041,23 +161041,23 @@ pub static WORD_DOCUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DOCUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUC_CHILDREN),
+static WORD_DOCUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ument")],
     values: &[&["document"]],
     range: 5..=5,
 };
 
-static WORD_DOCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCT_CHILDREN),
+static WORD_DOCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ines"),
         dictgen::InsensitiveStr::Ascii("irne"),
@@ -161068,12 +161068,12 @@ pub static WORD_DOCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_DOCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCS_CHILDREN),
+static WORD_DOCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tatistik"),
         dictgen::InsensitiveStr::Ascii("tinrg"),
@@ -161083,12 +161083,12 @@ pub static WORD_DOCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DOCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCR_CHILDREN),
+static WORD_DOCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ines"),
         dictgen::InsensitiveStr::Ascii("tine"),
@@ -161098,12 +161098,12 @@ pub static WORD_DOCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_DOCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCO_CHILDREN),
+static WORD_DOCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mentation"),
@@ -161121,12 +161121,12 @@ pub static WORD_DOCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DOCM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCM_CHILDREN),
+static WORD_DOCM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enetation"),
         dictgen::InsensitiveStr::Ascii("uent"),
@@ -161148,34 +161148,34 @@ pub static WORD_DOCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DOCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCK_CHILDREN),
+static WORD_DOCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("son")],
     values: &[&["dachshund"]],
     range: 3..=3,
 };
 
-static WORD_DOCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCE_CHILDREN),
+static WORD_DOCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("kr")],
     values: &[&["docker"]],
     range: 2..=2,
 };
 
-static WORD_DOCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCC_CHILDREN),
+static WORD_DOCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ument"),
         dictgen::InsensitiveStr::Ascii("umented"),
@@ -161185,12 +161185,12 @@ pub static WORD_DOCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOB_CHILDREN),
+static WORD_DOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -161210,12 +161210,12 @@ pub static WORD_DOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_DOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOA_CHILDREN),
+static WORD_DOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gonal"),
         dictgen::InsensitiveStr::Ascii("gonals"),
@@ -161237,12 +161237,12 @@ pub static WORD_DOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_DN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DN_CHILDREN),
+static WORD_DN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amically"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -161252,12 +161252,12 @@ pub static WORD_DN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DL_CHILDREN),
+static WORD_DL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eivery"),
         dictgen::InsensitiveStr::Ascii("oating"),
@@ -161266,23 +161266,23 @@ pub static WORD_DL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=6,
 };
 
-static WORD_DJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DJ_CHILDREN),
+static WORD_DJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ikstra")],
     values: &[&["dijkstra"]],
     range: 6..=6,
 };
 
-static WORD_DI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DI_CHILDREN),
+static WORD_DI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DI_CHILDREN),
     value: None,
 };
 
-static WORD_DI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DIA_NODE),
     None,
     Some(&WORD_DIC_NODE),
@@ -161311,12 +161311,12 @@ static WORD_DI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIV_CHILDREN),
+static WORD_DIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -161406,12 +161406,12 @@ pub static WORD_DIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIT_CHILDREN),
+static WORD_DIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actorship"),
         dictgen::InsensitiveStr::Ascii("ance"),
@@ -161443,12 +161443,12 @@ pub static WORD_DIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_DIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIS_CHILDREN),
+static WORD_DIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIS_CHILDREN),
     value: None,
 };
 
-static WORD_DIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISA_NODE),
     Some(&WORD_DISB_NODE),
     Some(&WORD_DISC_NODE),
@@ -161477,12 +161477,12 @@ static WORD_DIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISU_CHILDREN),
+static WORD_DISU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("css"),
@@ -161522,12 +161522,12 @@ pub static WORD_DISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DIST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIST_CHILDREN),
+static WORD_DIST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIST_CHILDREN),
     value: None,
 };
 
-static WORD_DIST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISTA_NODE),
     None,
     None,
@@ -161556,12 +161556,12 @@ static WORD_DIST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTU_CHILDREN),
+static WORD_DISTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bring"),
         dictgen::InsensitiveStr::Ascii("ingish"),
@@ -161593,12 +161593,12 @@ pub static WORD_DISTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DISTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTT_CHILDREN),
+static WORD_DISTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ributed"),
         dictgen::InsensitiveStr::Ascii("ribution"),
@@ -161607,12 +161607,12 @@ pub static WORD_DISTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_DISTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISTR_CHILDREN),
+static WORD_DISTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISTR_CHILDREN),
     value: None,
 };
 
-static WORD_DISTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISTRA_NODE),
     Some(&WORD_DISTRB_NODE),
     Some(&WORD_DISTRC_NODE),
@@ -161641,12 +161641,12 @@ static WORD_DISTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRU_CHILDREN),
+static WORD_DISTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("bance"),
@@ -161710,12 +161710,12 @@ pub static WORD_DISTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_DISTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRO_CHILDREN),
+static WORD_DISTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bute"),
         dictgen::InsensitiveStr::Ascii("buted"),
@@ -161741,12 +161741,12 @@ pub static WORD_DISTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_DISTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRI_CHILDREN),
+static WORD_DISTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bitor"),
         dictgen::InsensitiveStr::Ascii("bitors"),
@@ -161840,23 +161840,23 @@ pub static WORD_DISTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_DISTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRE_CHILDREN),
+static WORD_DISTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("buted")],
     values: &[&["distributed"]],
     range: 5..=5,
 };
 
-static WORD_DISTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRC_CHILDREN),
+static WORD_DISTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("its"),
@@ -161867,12 +161867,12 @@ pub static WORD_DISTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_DISTRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRB_CHILDREN),
+static WORD_DISTRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ute"),
         dictgen::InsensitiveStr::Ascii("uted"),
@@ -161892,12 +161892,12 @@ pub static WORD_DISTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_DISTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRA_CHILDREN),
+static WORD_DISTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bution"),
         dictgen::InsensitiveStr::Ascii("ccion"),
@@ -161923,12 +161923,12 @@ pub static WORD_DISTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_DISTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTO_CHILDREN),
+static WORD_DISTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rition"),
         dictgen::InsensitiveStr::Ascii("riton"),
@@ -161954,12 +161954,12 @@ pub static WORD_DISTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DISTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTN_CHILDREN),
+static WORD_DISTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -161989,12 +161989,12 @@ pub static WORD_DISTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DISTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISTI_CHILDREN),
+static WORD_DISTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISTI_CHILDREN),
     value: None,
 };
 
-static WORD_DISTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DISTIB_NODE),
     Some(&WORD_DISTIC_NODE),
@@ -162023,23 +162023,23 @@ static WORD_DISTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIU_CHILDREN),
+static WORD_DISTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ngished")],
     values: &[&["distinguished"]],
     range: 7..=7,
 };
 
-static WORD_DISTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIR_CHILDREN),
+static WORD_DISTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bance"),
         dictgen::InsensitiveStr::Ascii("bute"),
@@ -162065,12 +162065,12 @@ pub static WORD_DISTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_DISTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIN_CHILDREN),
+static WORD_DISTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -162160,12 +162160,12 @@ pub static WORD_DISTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_DISTIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIG_CHILDREN),
+static WORD_DISTIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uish"),
         dictgen::InsensitiveStr::Ascii("uished"),
@@ -162174,12 +162174,12 @@ pub static WORD_DISTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_DISTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIC_CHILDREN),
+static WORD_DISTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("ntion"),
@@ -162197,12 +162197,12 @@ pub static WORD_DISTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_DISTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIB_CHILDREN),
+static WORD_DISTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ute"),
         dictgen::InsensitiveStr::Ascii("uted"),
@@ -162224,12 +162224,12 @@ pub static WORD_DISTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_DISTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTE_CHILDREN),
+static WORD_DISTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ngish"),
         dictgen::InsensitiveStr::Ascii("rbance"),
@@ -162238,12 +162238,12 @@ pub static WORD_DISTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_DISTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTA_CHILDREN),
+static WORD_DISTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -162285,12 +162285,12 @@ pub static WORD_DISTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DISS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISS_CHILDREN),
+static WORD_DISS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISS_CHILDREN),
     value: None,
 };
 
-static WORD_DISS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISSA_NODE),
     Some(&WORD_DISSB_NODE),
     Some(&WORD_DISSC_NODE),
@@ -162319,12 +162319,12 @@ static WORD_DISS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSS_CHILDREN),
+static WORD_DISSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emble"),
         dictgen::InsensitiveStr::Ascii("embled"),
@@ -162356,12 +162356,12 @@ pub static WORD_DISSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_DISSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSR_CHILDREN),
+static WORD_DISSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("upt"),
         dictgen::InsensitiveStr::Ascii("upted"),
@@ -162372,12 +162372,12 @@ pub static WORD_DISSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DISSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSP_CHILDREN),
+static WORD_DISSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aointed"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -162393,12 +162393,12 @@ pub static WORD_DISSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DISSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSO_CHILDREN),
+static WORD_DISSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bediance"),
         dictgen::InsensitiveStr::Ascii("bediant"),
@@ -162426,12 +162426,12 @@ pub static WORD_DISSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DISSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSM_CHILDREN),
+static WORD_DISSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antle"),
         dictgen::InsensitiveStr::Ascii("antled"),
@@ -162467,12 +162467,12 @@ pub static WORD_DISSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DISSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSI_CHILDREN),
+static WORD_DISSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mialr"),
         dictgen::InsensitiveStr::Ascii("mialrity"),
@@ -162528,23 +162528,23 @@ pub static WORD_DISSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DISSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSH_CHILDREN),
+static WORD_DISSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("earteningly")],
     values: &[&["dishearteningly"]],
     range: 11..=11,
 };
 
-static WORD_DISSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSE_CHILDREN),
+static WORD_DISSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pointed"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -162554,12 +162554,12 @@ pub static WORD_DISSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_DISSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSC_CHILDREN),
+static WORD_DISSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onect"),
         dictgen::InsensitiveStr::Ascii("onnect"),
@@ -162623,12 +162623,12 @@ pub static WORD_DISSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISSB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSB_CHILDREN),
+static WORD_DISSB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -162639,12 +162639,12 @@ pub static WORD_DISSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_DISSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISSA_CHILDREN),
+static WORD_DISSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISSA_CHILDREN),
     value: None,
 };
 
-static WORD_DISSA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISSA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DISSAB_NODE),
     None,
@@ -162673,12 +162673,12 @@ static WORD_DISSA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISSAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAT_CHILDREN),
+static WORD_DISSAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isfed"),
         dictgen::InsensitiveStr::Ascii("isifed"),
@@ -162688,12 +162688,12 @@ pub static WORD_DISSAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_DISSAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAS_CHILDREN),
+static WORD_DISSAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emble"),
         dictgen::InsensitiveStr::Ascii("embled"),
@@ -162751,23 +162751,23 @@ pub static WORD_DISSAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_DISSAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAR_CHILDREN),
+static WORD_DISSAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ray")],
     values: &[&["disarray"]],
     range: 3..=3,
 };
 
-static WORD_DISSAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAP_CHILDREN),
+static WORD_DISSAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ates"),
@@ -162861,12 +162861,12 @@ pub static WORD_DISSAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_DISSAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAM_CHILDREN),
+static WORD_DISSAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biguate"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -162890,12 +162890,12 @@ pub static WORD_DISSAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_DISSAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAL_CHILDREN),
+static WORD_DISSAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("low"),
         dictgen::InsensitiveStr::Ascii("lowed"),
@@ -162919,12 +162919,12 @@ pub static WORD_DISSAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_DISSAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAG_CHILDREN),
+static WORD_DISSAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("reement"),
         dictgen::InsensitiveStr::Ascii("regation"),
@@ -162933,12 +162933,12 @@ pub static WORD_DISSAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=8,
 };
 
-static WORD_DISSAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAD_CHILDREN),
+static WORD_DISSAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("vantage"),
         dictgen::InsensitiveStr::Ascii("vantages"),
@@ -162947,12 +162947,12 @@ pub static WORD_DISSAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=8,
 };
 
-static WORD_DISSAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAB_CHILDREN),
+static WORD_DISSAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -162963,12 +162963,12 @@ pub static WORD_DISSAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_DISR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISR_CHILDREN),
+static WORD_DISR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecpect"),
         dictgen::InsensitiveStr::Ascii("ecpected"),
@@ -163058,12 +163058,12 @@ pub static WORD_DISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_DISQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISQ_CHILDREN),
+static WORD_DISQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aulified"),
         dictgen::InsensitiveStr::Ascii("ualifed"),
@@ -163079,12 +163079,12 @@ pub static WORD_DISQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_DISP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISP_CHILDREN),
+static WORD_DISP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISP_CHILDREN),
     value: None,
 };
 
-static WORD_DISP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISPA_NODE),
     Some(&WORD_DISPB_NODE),
     None,
@@ -163113,12 +163113,12 @@ static WORD_DISP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPU_CHILDREN),
+static WORD_DISPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("tandem"),
@@ -163134,23 +163134,23 @@ pub static WORD_DISPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DISPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPT_CHILDREN),
+static WORD_DISPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ach")],
     values: &[&["dispatch"]],
     range: 3..=3,
 };
 
-static WORD_DISPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPR_CHILDREN),
+static WORD_DISPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aportionate"),
         dictgen::InsensitiveStr::Ascii("aportionately"),
@@ -163188,12 +163188,12 @@ pub static WORD_DISPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=14,
 };
 
-static WORD_DISPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPP_CHILDREN),
+static WORD_DISPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lay"),
         dictgen::InsensitiveStr::Ascii("rove"),
@@ -163202,12 +163202,12 @@ pub static WORD_DISPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DISPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPO_CHILDREN),
+static WORD_DISPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -163261,12 +163261,12 @@ pub static WORD_DISPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_DISPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPL_CHILDREN),
+static WORD_DISPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("acemnt"),
@@ -163304,12 +163304,12 @@ pub static WORD_DISPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DISPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPI_CHILDREN),
+static WORD_DISPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("rsed"),
@@ -163319,12 +163319,12 @@ pub static WORD_DISPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DISPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPE_CHILDREN),
+static WORD_DISPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -163376,23 +163376,23 @@ pub static WORD_DISPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_DISPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPB_CHILDREN),
+static WORD_DISPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ibute")],
     values: &[&["distribute"]],
     range: 5..=5,
 };
 
-static WORD_DISPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPA_CHILDREN),
+static WORD_DISPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cement"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -163458,12 +163458,12 @@ pub static WORD_DISPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISO_CHILDREN),
+static WORD_DISO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bediance"),
         dictgen::InsensitiveStr::Ascii("bediant"),
@@ -163503,12 +163503,12 @@ pub static WORD_DISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DISN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISN_CHILDREN),
+static WORD_DISN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abled"),
         dictgen::InsensitiveStr::Ascii("egage"),
@@ -163517,12 +163517,12 @@ pub static WORD_DISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_DISM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISM_CHILDREN),
+static WORD_DISM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abiguation"),
         dictgen::InsensitiveStr::Ascii("anlting"),
@@ -163558,12 +163558,12 @@ pub static WORD_DISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_DISL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISL_CHILDREN),
+static WORD_DISL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aimer"),
         dictgen::InsensitiveStr::Ascii("ay"),
@@ -163595,12 +163595,12 @@ pub static WORD_DISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DISK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISK_CHILDREN),
+static WORD_DISK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rete"),
         dictgen::InsensitiveStr::Ascii("retion"),
@@ -163620,12 +163620,12 @@ pub static WORD_DISK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_DISI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISI_CHILDREN),
+static WORD_DISI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cples"),
         dictgen::InsensitiveStr::Ascii("cpline"),
@@ -163679,12 +163679,12 @@ pub static WORD_DISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_DISH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISH_CHILDREN),
+static WORD_DISH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arge"),
         dictgen::InsensitiveStr::Ascii("carged"),
@@ -163706,12 +163706,12 @@ pub static WORD_DISH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DISG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISG_CHILDREN),
+static WORD_DISG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arded"),
         dictgen::InsensitiveStr::Ascii("areement"),
@@ -163793,12 +163793,12 @@ pub static WORD_DISG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISF_CHILDREN),
+static WORD_DISF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("unctional"),
         dictgen::InsensitiveStr::Ascii("unctionality"),
@@ -163807,12 +163807,12 @@ pub static WORD_DISF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=12,
 };
 
-static WORD_DISE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISE_CHILDREN),
+static WORD_DISE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cting"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -163844,23 +163844,23 @@ pub static WORD_DISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DISD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISD_CHILDREN),
+static WORD_DISD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("vantage")],
     values: &[&["disadvantage"]],
     range: 7..=7,
 };
 
-static WORD_DISC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISC_CHILDREN),
+static WORD_DISC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISC_CHILDREN),
     value: None,
 };
 
-static WORD_DISC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISCA_NODE),
     None,
     Some(&WORD_DISCC_NODE),
@@ -163889,12 +163889,12 @@ static WORD_DISC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCU_CHILDREN),
+static WORD_DISCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alified"),
         dictgen::InsensitiveStr::Ascii("assed"),
@@ -163938,12 +163938,12 @@ pub static WORD_DISCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DISCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCT_CHILDREN),
+static WORD_DISCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inction"),
         dictgen::InsensitiveStr::Ascii("inctive"),
@@ -163963,12 +163963,12 @@ pub static WORD_DISCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_DISCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCR_CHILDREN),
+static WORD_DISCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -164080,23 +164080,23 @@ pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DISCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCP_CHILDREN),
+static WORD_DISCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("line")],
     values: &[&["discipline"]],
     range: 4..=4,
 };
 
-static WORD_DISCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISCO_CHILDREN),
+static WORD_DISCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISCO_CHILDREN),
     value: None,
 };
 
-static WORD_DISCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -164125,12 +164125,12 @@ static WORD_DISCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISCOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOV_CHILDREN),
+static WORD_DISCOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -164166,12 +164166,12 @@ pub static WORD_DISCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_DISCOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOU_CHILDREN),
+static WORD_DISCOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ntined"),
@@ -164201,12 +164201,12 @@ pub static WORD_DISCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_DISCOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOT_CHILDREN),
+static WORD_DISCOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ek"),
         dictgen::InsensitiveStr::Ascii("eque"),
@@ -164215,23 +164215,23 @@ pub static WORD_DISCOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_DISCOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOS_CHILDREN),
+static WORD_DISCOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ure")],
     values: &[&["discourse"]],
     range: 3..=3,
 };
 
-static WORD_DISCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOR_CHILDREN),
+static WORD_DISCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aged"),
         dictgen::InsensitiveStr::Ascii("uage"),
@@ -164240,12 +164240,12 @@ pub static WORD_DISCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=4,
 };
 
-static WORD_DISCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCON_CHILDREN),
+static WORD_DISCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCON_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecct"),
         dictgen::InsensitiveStr::Ascii("eccted"),
@@ -164361,23 +164361,23 @@ pub static WORD_DISCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_DISCOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOL_CHILDREN),
+static WORD_DISCOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sure")],
     values: &[&["disclosure"]],
     range: 4..=4,
 };
 
-static WORD_DISCOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOG_CHILDREN),
+static WORD_DISCOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rahy"),
         dictgen::InsensitiveStr::Ascii("rapy"),
@@ -164393,12 +164393,12 @@ pub static WORD_DISCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_DISCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCL_CHILDREN),
+static WORD_DISCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amer"),
         dictgen::InsensitiveStr::Ascii("amier"),
@@ -164426,12 +164426,12 @@ pub static WORD_DISCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_DISCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCI_CHILDREN),
+static WORD_DISCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("menation"),
         dictgen::InsensitiveStr::Ascii("minate"),
@@ -164479,12 +164479,12 @@ pub static WORD_DISCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_DISCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCH_CHILDREN),
+static WORD_DISCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("arded"),
@@ -164498,12 +164498,12 @@ pub static WORD_DISCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DISCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCE_CHILDREN),
+static WORD_DISCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pline"),
         dictgen::InsensitiveStr::Ascii("ption"),
@@ -164519,12 +164519,12 @@ pub static WORD_DISCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DISCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCC_CHILDREN),
+static WORD_DISCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onecct"),
         dictgen::InsensitiveStr::Ascii("oneccted"),
@@ -164596,12 +164596,12 @@ pub static WORD_DISCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DISCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCA_CHILDREN),
+static WORD_DISCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("limer"),
         dictgen::InsensitiveStr::Ascii("pline"),
@@ -164619,12 +164619,12 @@ pub static WORD_DISCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DISB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISB_CHILDREN),
+static WORD_DISB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -164650,12 +164650,12 @@ pub static WORD_DISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DISA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISA_CHILDREN),
+static WORD_DISA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISA_CHILDREN),
     value: None,
 };
 
-static WORD_DISA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISAA_NODE),
     Some(&WORD_DISAB_NODE),
     None,
@@ -164684,12 +164684,12 @@ static WORD_DISA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAT_CHILDREN),
+static WORD_DISAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erous"),
         dictgen::InsensitiveStr::Ascii("isfaction"),
@@ -164715,12 +164715,12 @@ pub static WORD_DISAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DISAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAS_CHILDREN),
+static WORD_DISAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emble"),
         dictgen::InsensitiveStr::Ascii("embled"),
@@ -164788,12 +164788,12 @@ pub static WORD_DISAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DISAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAR_CHILDREN),
+static WORD_DISAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -164802,12 +164802,12 @@ pub static WORD_DISAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_DISAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAP_CHILDREN),
+static WORD_DISAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ait"),
         dictgen::InsensitiveStr::Ascii("aited"),
@@ -164925,12 +164925,12 @@ pub static WORD_DISAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DISAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAM_CHILDREN),
+static WORD_DISAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bigation"),
         dictgen::InsensitiveStr::Ascii("bigouate"),
@@ -164950,12 +164950,12 @@ pub static WORD_DISAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_DISAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAL_CHILDREN),
+static WORD_DISAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -164979,12 +164979,12 @@ pub static WORD_DISAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAG_CHILDREN),
+static WORD_DISAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("red"),
         dictgen::InsensitiveStr::Ascii("reeed"),
@@ -165006,12 +165006,12 @@ pub static WORD_DISAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DISAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAD_CHILDREN),
+static WORD_DISAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("vandage"),
         dictgen::InsensitiveStr::Ascii("vandages"),
@@ -165045,12 +165045,12 @@ pub static WORD_DISAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_DISAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAB_CHILDREN),
+static WORD_DISAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -165096,12 +165096,12 @@ pub static WORD_DISAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAA_CHILDREN),
+static WORD_DISAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("point"),
         dictgen::InsensitiveStr::Ascii("pointed"),
@@ -165110,12 +165110,12 @@ pub static WORD_DISAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIR_CHILDREN),
+static WORD_DIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIR_CHILDREN),
     value: None,
 };
 
-static WORD_DIR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DIRA_NODE),
     Some(&WORD_DIRB_NODE),
     Some(&WORD_DIRC_NODE),
@@ -165144,12 +165144,12 @@ static WORD_DIR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIRV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRV_CHILDREN),
+static WORD_DIRV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -165167,12 +165167,12 @@ pub static WORD_DIRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_DIRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRT_CHILDREN),
+static WORD_DIRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectory"),
         dictgen::InsensitiveStr::Ascii("yed"),
@@ -165182,12 +165182,12 @@ pub static WORD_DIRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRR_CHILDREN),
+static WORD_DIRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ection"),
         dictgen::InsensitiveStr::Ascii("ectly"),
@@ -165196,34 +165196,34 @@ pub static WORD_DIRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_DIRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRI_CHILDREN),
+static WORD_DIRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ved")],
     values: &[&["derived"]],
     range: 3..=3,
 };
 
-static WORD_DIRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRF_CHILDREN),
+static WORD_DIRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ting")],
     values: &[&["drifting"]],
     range: 4..=4,
 };
 
-static WORD_DIRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIRE_CHILDREN),
+static WORD_DIRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIRE_CHILDREN),
     value: None,
 };
 
-static WORD_DIRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DIREC_NODE),
@@ -165252,23 +165252,23 @@ static WORD_DIRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIREV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREV_CHILDREN),
+static WORD_DIREV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ctory")],
     values: &[&["directory"]],
     range: 5..=5,
 };
 
-static WORD_DIRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRET_CHILDREN),
+static WORD_DIRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRET_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cx"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -165288,23 +165288,23 @@ pub static WORD_DIRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRES_CHILDREN),
+static WORD_DIRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ired")],
     values: &[&["desired"]],
     range: 4..=4,
 };
 
-static WORD_DIRER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRER_CHILDREN),
+static WORD_DIRER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRER_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctor"),
         dictgen::InsensitiveStr::Ascii("ctories"),
@@ -165320,12 +165320,12 @@ pub static WORD_DIRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_DIREK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREK_CHILDREN),
+static WORD_DIREK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tional"),
         dictgen::InsensitiveStr::Ascii("tly"),
@@ -165334,45 +165334,45 @@ pub static WORD_DIREK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREG_CHILDREN),
+static WORD_DIREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ard")],
     values: &[&["disregard"]],
     range: 3..=3,
 };
 
-static WORD_DIREF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREF_CHILDREN),
+static WORD_DIREF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tory")],
     values: &[&["directory"]],
     range: 4..=4,
 };
 
-static WORD_DIREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREE_CHILDREN),
+static WORD_DIREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ctly")],
     values: &[&["directly"]],
     range: 4..=4,
 };
 
-static WORD_DIREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIREC_CHILDREN),
+static WORD_DIREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIREC_CHILDREN),
     value: None,
 };
 
-static WORD_DIREC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIREC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DIRECC_NODE),
@@ -165401,12 +165401,12 @@ static WORD_DIREC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIRECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECT_CHILDREN),
+static WORD_DIRECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -165520,23 +165520,23 @@ pub static WORD_DIRECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_DIRECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECR_CHILDREN),
+static WORD_DIRECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["directed"]],
     range: 3..=3,
 };
 
-static WORD_DIRECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECO_CHILDREN),
+static WORD_DIRECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ries"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -165558,12 +165558,12 @@ pub static WORD_DIRECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_DIRECL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECL_CHILDREN),
+static WORD_DIRECL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ty"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -165572,12 +165572,12 @@ pub static WORD_DIRECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_DIRECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECI_CHILDREN),
+static WORD_DIRECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("onal"),
@@ -165601,12 +165601,12 @@ pub static WORD_DIRECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_DIRECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECE_CHILDREN),
+static WORD_DIRECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tories"),
         dictgen::InsensitiveStr::Ascii("tory"),
@@ -165615,12 +165615,12 @@ pub static WORD_DIRECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_DIRECD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECD_CHILDREN),
+static WORD_DIRECD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ories"),
         dictgen::InsensitiveStr::Ascii("ory"),
@@ -165630,12 +165630,12 @@ pub static WORD_DIRECD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_DIRECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECC_CHILDREN),
+static WORD_DIRECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -165655,12 +165655,12 @@ pub static WORD_DIRECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_DIRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRC_CHILDREN),
+static WORD_DIRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etories"),
@@ -165682,23 +165682,23 @@ pub static WORD_DIRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DIRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRB_CHILDREN),
+static WORD_DIRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ble")],
     values: &[&["dribble"]],
     range: 3..=3,
 };
 
-static WORD_DIRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRA_CHILDREN),
+static WORD_DIRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tions"),
@@ -165707,23 +165707,23 @@ pub static WORD_DIRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_DIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIQ_CHILDREN),
+static WORD_DIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["dial"]],
     range: 1..=1,
 };
 
-static WORD_DIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIP_CHILDREN),
+static WORD_DIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atch"),
         dictgen::InsensitiveStr::Ascii("ections"),
@@ -165783,12 +165783,12 @@ pub static WORD_DIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_DIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIO_CHILDREN),
+static WORD_DIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("log"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -165808,12 +165808,12 @@ pub static WORD_DIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_DIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIN_CHILDREN),
+static WORD_DIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("amic"),
@@ -165869,12 +165869,12 @@ pub static WORD_DIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_DIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIM_CHILDREN),
+static WORD_DIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("and"),
         dictgen::InsensitiveStr::Ascii("ands"),
@@ -166000,12 +166000,12 @@ pub static WORD_DIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_DIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIL_CHILDREN),
+static WORD_DIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aog"),
         dictgen::InsensitiveStr::Ascii("ema"),
@@ -166037,12 +166037,12 @@ pub static WORD_DIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_DIJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIJ_CHILDREN),
+static WORD_DIJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("skstra"),
         dictgen::InsensitiveStr::Ascii("sktra"),
@@ -166052,12 +166052,12 @@ pub static WORD_DIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_DIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIG_CHILDREN),
+static WORD_DIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anose"),
         dictgen::InsensitiveStr::Ascii("anosed"),
@@ -166103,12 +166103,12 @@ pub static WORD_DIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_DIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIF_CHILDREN),
+static WORD_DIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIF_CHILDREN),
     value: None,
 };
 
-static WORD_DIF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -166137,12 +166137,12 @@ static WORD_DIF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFU_CHILDREN),
+static WORD_DIFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("sed"),
@@ -166160,12 +166160,12 @@ pub static WORD_DIFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFR_CHILDREN),
+static WORD_DIFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -166183,12 +166183,12 @@ pub static WORD_DIFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFI_CHILDREN),
+static WORD_DIFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cult"),
         dictgen::InsensitiveStr::Ascii("culties"),
@@ -166214,12 +166214,12 @@ pub static WORD_DIFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DIFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIFF_CHILDREN),
+static WORD_DIFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIFF_CHILDREN),
     value: None,
 };
 
-static WORD_DIFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIFF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DIFFC_NODE),
@@ -166248,12 +166248,12 @@ static WORD_DIFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIFFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFU_CHILDREN),
+static WORD_DIFFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clt"),
         dictgen::InsensitiveStr::Ascii("cult"),
@@ -166277,12 +166277,12 @@ pub static WORD_DIFFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DIFFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFR_CHILDREN),
+static WORD_DIFFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eences"),
         dictgen::InsensitiveStr::Ascii("eent"),
@@ -166316,12 +166316,12 @@ pub static WORD_DIFFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DIFFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFI_CHILDREN),
+static WORD_DIFFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cault"),
         dictgen::InsensitiveStr::Ascii("caulties"),
@@ -166361,12 +166361,12 @@ pub static WORD_DIFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DIFFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFF_CHILDREN),
+static WORD_DIFFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ered"),
         dictgen::InsensitiveStr::Ascii("erence"),
@@ -166386,12 +166386,12 @@ pub static WORD_DIFFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DIFFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIFFE_CHILDREN),
+static WORD_DIFFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIFFE_CHILDREN),
     value: None,
 };
 
-static WORD_DIFFE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIFFE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -166420,12 +166420,12 @@ static WORD_DIFFE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIFFER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIFFER_CHILDREN),
+static WORD_DIFFER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIFFER_CHILDREN),
     value: None,
 };
 
-static WORD_DIFFER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIFFER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DIFFERA_NODE),
     None,
     None,
@@ -166454,12 +166454,12 @@ static WORD_DIFFER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIFFERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERR_CHILDREN),
+static WORD_DIFFERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -166477,12 +166477,12 @@ pub static WORD_DIFFERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=5,
 };
 
-static WORD_DIFFERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERN_CHILDREN),
+static WORD_DIFFERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -166542,12 +166542,12 @@ pub static WORD_DIFFERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_DIFFERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERI_CHILDREN),
+static WORD_DIFFERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ator"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -166561,12 +166561,12 @@ pub static WORD_DIFFERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=8,
 };
 
-static WORD_DIFFERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERE_CHILDREN),
+static WORD_DIFFERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -166656,12 +166656,12 @@ pub static WORD_DIFFERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=12,
 };
 
-static WORD_DIFFERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERA_CHILDREN),
+static WORD_DIFFERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nce"),
         dictgen::InsensitiveStr::Ascii("nces"),
@@ -166687,12 +166687,12 @@ pub static WORD_DIFFERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_DIFFEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFEN_CHILDREN),
+static WORD_DIFFEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -166716,23 +166716,23 @@ pub static WORD_DIFFEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_DIFFEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFEE_CHILDREN),
+static WORD_DIFFEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nt")],
     values: &[&["different"]],
     range: 2..=2,
 };
 
-static WORD_DIFFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFC_CHILDREN),
+static WORD_DIFFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ult"),
         dictgen::InsensitiveStr::Ascii("ulties"),
@@ -166742,12 +166742,12 @@ pub static WORD_DIFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFE_CHILDREN),
+static WORD_DIFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nitly"),
         dictgen::InsensitiveStr::Ascii("rence"),
@@ -166775,12 +166775,12 @@ pub static WORD_DIFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_DIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIE_CHILDREN),
+static WORD_DIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("abled"),
@@ -166814,12 +166814,12 @@ pub static WORD_DIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DID_CHILDREN),
+static WORD_DID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DID_CHILDREN),
     value: None,
 };
 
-pub static WORD_DID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("sapointed"),
@@ -166828,12 +166828,12 @@ pub static WORD_DID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_DIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIC_CHILDREN),
+static WORD_DIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIC_CHILDREN),
     value: None,
 };
 
-static WORD_DIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DICA_NODE),
     None,
     None,
@@ -166862,12 +166862,12 @@ static WORD_DIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DICU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICU_CHILDREN),
+static WORD_DICU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ss"),
         dictgen::InsensitiveStr::Ascii("ssed"),
@@ -166885,12 +166885,12 @@ pub static WORD_DICU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DICT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICT_CHILDREN),
+static WORD_DICT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adorship"),
         dictgen::InsensitiveStr::Ascii("aionaries"),
@@ -166960,12 +166960,12 @@ pub static WORD_DICT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DICS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICS_CHILDREN),
+static WORD_DICS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("riminated"),
         dictgen::InsensitiveStr::Ascii("uss"),
@@ -166974,12 +166974,12 @@ pub static WORD_DICS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DICR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICR_CHILDREN),
+static WORD_DICR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectory"),
         dictgen::InsensitiveStr::Ascii("ete"),
@@ -167007,12 +167007,12 @@ pub static WORD_DICR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DICO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICO_CHILDREN),
+static WORD_DICO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nnected"),
         dictgen::InsensitiveStr::Ascii("nnection"),
@@ -167042,23 +167042,23 @@ pub static WORD_DICO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DICL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICL_CHILDREN),
+static WORD_DICL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ine")],
     values: &[&["decline"]],
     range: 3..=3,
 };
 
-static WORD_DICK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICK_CHILDREN),
+static WORD_DICK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isch"),
         dictgen::InsensitiveStr::Ascii("sih"),
@@ -167067,12 +167067,12 @@ pub static WORD_DICK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DICI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICI_CHILDREN),
+static WORD_DICI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -167102,12 +167102,12 @@ pub static WORD_DICI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DICH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICH_CHILDREN),
+static WORD_DICH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omoty"),
         dictgen::InsensitiveStr::Ascii("otomoy"),
@@ -167117,23 +167117,23 @@ pub static WORD_DICH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DICE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICE_CHILDREN),
+static WORD_DICE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rgence")],
     values: &[&["divergence"]],
     range: 6..=6,
 };
 
-static WORD_DICA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICA_CHILDREN),
+static WORD_DICA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rded"),
@@ -167155,12 +167155,12 @@ pub static WORD_DICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIA_CHILDREN),
+static WORD_DIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIA_CHILDREN),
     value: None,
 };
 
-static WORD_DIA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DIAA_NODE),
     Some(&WORD_DIAB_NODE),
     Some(&WORD_DIAC_NODE),
@@ -167189,12 +167189,12 @@ static WORD_DIA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAT_CHILDREN),
+static WORD_DIAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ancing"),
@@ -167203,12 +167203,12 @@ pub static WORD_DIAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DIAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAS_CHILDREN),
+static WORD_DIAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bled"),
@@ -167238,12 +167238,12 @@ pub static WORD_DIAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DIAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAR_CHILDREN),
+static WORD_DIAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("ea"),
@@ -167265,12 +167265,12 @@ pub static WORD_DIAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAP_CHILDREN),
+static WORD_DIAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lay"),
         dictgen::InsensitiveStr::Ascii("lays"),
@@ -167280,12 +167280,12 @@ pub static WORD_DIAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAN_CHILDREN),
+static WORD_DIAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gose"),
         dictgen::InsensitiveStr::Ascii("ostic"),
@@ -167295,12 +167295,12 @@ pub static WORD_DIAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DIAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAM_CHILDREN),
+static WORD_DIAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ater"),
         dictgen::InsensitiveStr::Ascii("aters"),
@@ -167320,12 +167320,12 @@ pub static WORD_DIAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAL_CHILDREN),
+static WORD_DIAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aog"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -167363,23 +167363,23 @@ pub static WORD_DIAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAH_CHILDREN),
+static WORD_DIAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rrea")],
     values: &[&["diarrhea"]],
     range: 4..=4,
 };
 
-static WORD_DIAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAG_CHILDREN),
+static WORD_DIAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anol"),
         dictgen::InsensitiveStr::Ascii("inal"),
@@ -167457,12 +167457,12 @@ pub static WORD_DIAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DIAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAC_CHILDREN),
+static WORD_DIAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iritc"),
         dictgen::InsensitiveStr::Ascii("iritcs"),
@@ -167471,12 +167471,12 @@ pub static WORD_DIAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_DIAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAB_CHILDREN),
+static WORD_DIAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etees"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -167504,34 +167504,34 @@ pub static WORD_DIAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAA_CHILDREN),
+static WORD_DIAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bled")],
     values: &[&["disabled"]],
     range: 4..=4,
 };
 
-static WORD_DG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DG_CHILDREN),
+static WORD_DG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etttext")],
     values: &[&["dgettext"]],
     range: 7..=7,
 };
 
-static WORD_DF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DF_CHILDREN),
+static WORD_DF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -167549,12 +167549,12 @@ pub static WORD_DF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_DE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DE_CHILDREN),
+static WORD_DE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DE_CHILDREN),
     value: None,
 };
 
-static WORD_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEA_NODE),
     Some(&WORD_DEB_NODE),
     Some(&WORD_DEC_NODE),
@@ -167583,12 +167583,12 @@ static WORD_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEZ_NODE),
 ];
 
-static WORD_DEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEZ_CHILDREN),
+static WORD_DEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ember"),
         dictgen::InsensitiveStr::Ascii("entralized"),
@@ -167608,12 +167608,12 @@ pub static WORD_DEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_DEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEY_CHILDREN),
+static WORD_DEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hdrated"),
         dictgen::InsensitiveStr::Ascii("hdration"),
@@ -167622,23 +167622,23 @@ pub static WORD_DEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_DEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEW_CHILDREN),
+static WORD_DEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rapping")],
     values: &[&["unwrapping"]],
     range: 7..=7,
 };
 
-static WORD_DEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEV_CHILDREN),
+static WORD_DEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEV_CHILDREN),
     value: None,
 };
 
-static WORD_DEV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEVA_NODE),
     None,
     Some(&WORD_DEVC_NODE),
@@ -167667,34 +167667,34 @@ static WORD_DEV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEVY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVY_CHILDREN),
+static WORD_DEVY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVY_CHILDREN),
     value: Some(&["divvy"]),
 };
 
-pub static WORD_DEVY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DEVU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVU_CHILDREN),
+static WORD_DEVU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ce")],
     values: &[&["device"]],
     range: 2..=2,
 };
 
-static WORD_DEVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVR_CHILDREN),
+static WORD_DEVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itualisation"),
         dictgen::InsensitiveStr::Ascii("itualization"),
@@ -167703,12 +167703,12 @@ pub static WORD_DEVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 12..=12,
 };
 
-static WORD_DEVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVO_CHILDREN),
+static WORD_DEVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lopement"),
         dictgen::InsensitiveStr::Ascii("lopments"),
@@ -167730,12 +167730,12 @@ pub static WORD_DEVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DEVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVL_CHILDREN),
+static WORD_DEVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eop"),
         dictgen::InsensitiveStr::Ascii("eoped"),
@@ -167783,12 +167783,12 @@ pub static WORD_DEVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DEVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVI_CHILDREN),
+static WORD_DEVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alet"),
         dictgen::InsensitiveStr::Ascii("atie"),
@@ -167892,12 +167892,12 @@ pub static WORD_DEVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=14,
 };
 
-static WORD_DEVF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVF_CHILDREN),
+static WORD_DEVF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -167907,12 +167907,12 @@ pub static WORD_DEVF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DEVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVE_CHILDREN),
+static WORD_DEVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lepmont"),
         dictgen::InsensitiveStr::Ascii("lepors"),
@@ -168032,12 +168032,12 @@ pub static WORD_DEVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_DEVC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVC_CHILDREN),
+static WORD_DEVC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -168055,12 +168055,12 @@ pub static WORD_DEVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DEVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVA_CHILDREN),
+static WORD_DEVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("int"),
         dictgen::InsensitiveStr::Ascii("ite"),
@@ -168084,12 +168084,12 @@ pub static WORD_DEVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEU_CHILDREN),
+static WORD_DEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bug"),
         dictgen::InsensitiveStr::Ascii("buging"),
@@ -168121,12 +168121,12 @@ pub static WORD_DEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DET_CHILDREN),
+static WORD_DET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DET_CHILDREN),
     value: None,
 };
 
-static WORD_DET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DET_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DETA_NODE),
     None,
     Some(&WORD_DETC_NODE),
@@ -168155,12 +168155,12 @@ static WORD_DET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DETU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETU_CHILDREN),
+static WORD_DETU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rance"),
@@ -168170,12 +168170,12 @@ pub static WORD_DETU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DETT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETT_CHILDREN),
+static WORD_DETT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -168185,12 +168185,12 @@ pub static WORD_DETT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DETR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETR_CHILDREN),
+static WORD_DETR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amental"),
         dictgen::InsensitiveStr::Ascii("emental"),
@@ -168230,34 +168230,34 @@ pub static WORD_DETR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DETO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETO_CHILDREN),
+static WORD_DETO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rit")],
     values: &[&["detroit"]],
     range: 3..=3,
 };
 
-static WORD_DETM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETM_CHILDREN),
+static WORD_DETM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atologist")],
     values: &[&["dermatologist"]],
     range: 9..=9,
 };
 
-static WORD_DETI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETI_CHILDREN),
+static WORD_DETI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -168279,12 +168279,12 @@ pub static WORD_DETI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DETE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DETE_CHILDREN),
+static WORD_DETE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DETE_CHILDREN),
     value: None,
 };
 
-static WORD_DETE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DETE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DETEC_NODE),
@@ -168313,12 +168313,12 @@ static WORD_DETE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DETET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETET_CHILDREN),
+static WORD_DETET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETET_CHILDREN),
     value: Some(&["detect", "delete"]),
 };
 
-pub static WORD_DETET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -168340,12 +168340,12 @@ pub static WORD_DETET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_DETER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETER_CHILDREN),
+static WORD_DETER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETER_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("emine"),
@@ -168475,23 +168475,23 @@ pub static WORD_DETER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_DETEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETEO_CHILDREN),
+static WORD_DETEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("riated")],
     values: &[&["deteriorated"]],
     range: 6..=6,
 };
 
-static WORD_DETEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETEM_CHILDREN),
+static WORD_DETEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -168507,12 +168507,12 @@ pub static WORD_DETEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DETEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETEC_CHILDREN),
+static WORD_DETEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eted"),
@@ -168568,12 +168568,12 @@ pub static WORD_DETEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DETC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETC_CHILDREN),
+static WORD_DETC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eting"),
         dictgen::InsensitiveStr::Ascii("etion"),
@@ -168597,12 +168597,12 @@ pub static WORD_DETC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DETA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETA_CHILDREN),
+static WORD_DETA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("base"),
         dictgen::InsensitiveStr::Ascii("chs"),
@@ -168652,12 +168652,12 @@ pub static WORD_DETA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DES_CHILDREN),
+static WORD_DES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DES_CHILDREN),
     value: None,
 };
 
-static WORD_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DESA_NODE),
     None,
     Some(&WORD_DESC_NODE),
@@ -168686,12 +168686,12 @@ static WORD_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESY_CHILDREN),
+static WORD_DESY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chronize"),
         dictgen::InsensitiveStr::Ascii("chronized"),
@@ -168700,23 +168700,23 @@ pub static WORD_DESY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_DESU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESU_CHILDREN),
+static WORD_DESU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ction")],
     values: &[&["seduction"]],
     range: 5..=5,
 };
 
-static WORD_DEST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEST_CHILDREN),
+static WORD_DEST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEST_CHILDREN),
     value: None,
 };
 
-static WORD_DEST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DESTA_NODE),
     None,
     None,
@@ -168745,12 +168745,12 @@ static WORD_DEST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTU_CHILDREN),
+static WORD_DESTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -168778,23 +168778,23 @@ pub static WORD_DESTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DESTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTT_CHILDREN),
+static WORD_DESTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ructor")],
     values: &[&["destructor"]],
     range: 6..=6,
 };
 
-static WORD_DESTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTR_CHILDREN),
+static WORD_DESTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("action"),
         dictgen::InsensitiveStr::Ascii("actions"),
@@ -168900,12 +168900,12 @@ pub static WORD_DESTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DESTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTO_CHILDREN),
+static WORD_DESTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("ps"),
@@ -168941,12 +168941,12 @@ pub static WORD_DESTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_DESTK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTK_CHILDREN),
+static WORD_DESTK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("op"),
         dictgen::InsensitiveStr::Ascii("ops"),
@@ -168955,12 +168955,12 @@ pub static WORD_DESTK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_DESTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTI_CHILDREN),
+static WORD_DESTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antion"),
         dictgen::InsensitiveStr::Ascii("antions"),
@@ -169032,23 +169032,23 @@ pub static WORD_DESTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DESTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTE_CHILDREN),
+static WORD_DESTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ctor")],
     values: &[&["detector"]],
     range: 4..=4,
 };
 
-static WORD_DESTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTA_CHILDREN),
+static WORD_DESTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blized"),
         dictgen::InsensitiveStr::Ascii("nation"),
@@ -169064,12 +169064,12 @@ pub static WORD_DESTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESS_CHILDREN),
+static WORD_DESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cribe"),
         dictgen::InsensitiveStr::Ascii("cribing"),
@@ -169095,12 +169095,12 @@ pub static WORD_DESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_DESR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESR_CHILDREN),
+static WORD_DESR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciption"),
         dictgen::InsensitiveStr::Ascii("ciptions"),
@@ -169138,23 +169138,23 @@ pub static WORD_DESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DESQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESQ_CHILDREN),
+static WORD_DESQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ualified")],
     values: &[&["disqualified"]],
     range: 8..=8,
 };
 
-static WORD_DESP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESP_CHILDREN),
+static WORD_DESP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("arately"),
@@ -169220,12 +169220,12 @@ pub static WORD_DESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DESO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESO_CHILDREN),
+static WORD_DESO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("gned"),
@@ -169251,12 +169251,12 @@ pub static WORD_DESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DESN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESN_CHILDREN),
+static WORD_DESN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -169272,12 +169272,12 @@ pub static WORD_DESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_DESL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESL_CHILDREN),
+static WORD_DESL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -169288,12 +169288,12 @@ pub static WORD_DESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DESK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESK_CHILDREN),
+static WORD_DESK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("op"),
         dictgen::InsensitiveStr::Ascii("ops"),
@@ -169313,12 +169313,12 @@ pub static WORD_DESK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DESI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESI_CHILDREN),
+static WORD_DESI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("cate"),
@@ -169444,12 +169444,12 @@ pub static WORD_DESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_DESG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESG_CHILDREN),
+static WORD_DESG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("inated"),
@@ -169477,12 +169477,12 @@ pub static WORD_DESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESE_CHILDREN),
+static WORD_DESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lct"),
         dictgen::InsensitiveStr::Ascii("lctable"),
@@ -169564,12 +169564,12 @@ pub static WORD_DESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_DESC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DESC_CHILDREN),
+static WORD_DESC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DESC_CHILDREN),
     value: None,
 };
 
-static WORD_DESC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DESC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DESCA_NODE),
     None,
     Some(&WORD_DESCC_NODE),
@@ -169598,12 +169598,12 @@ static WORD_DESC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESCV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCV_CHILDREN),
+static WORD_DESCV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ription"),
         dictgen::InsensitiveStr::Ascii("riptions"),
@@ -169612,23 +169612,23 @@ pub static WORD_DESCV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_DESCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCU_CHILDREN),
+static WORD_DESCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ss")],
     values: &[&["discuss"]],
     range: 2..=2,
 };
 
-static WORD_DESCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCT_CHILDREN),
+static WORD_DESCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iption"),
         dictgen::InsensitiveStr::Ascii("iptions"),
@@ -169658,12 +169658,12 @@ pub static WORD_DESCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DESCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DESCR_CHILDREN),
+static WORD_DESCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DESCR_CHILDREN),
     value: None,
 };
 
-static WORD_DESCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DESCR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DESCRB_NODE),
     None,
@@ -169692,12 +169692,12 @@ static WORD_DESCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESCRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRY_CHILDREN),
+static WORD_DESCRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("bing"),
@@ -169713,23 +169713,23 @@ pub static WORD_DESCRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_DESCRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRU_CHILDREN),
+static WORD_DESCRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tor")],
     values: &[&["destructor"]],
     range: 3..=3,
 };
 
-static WORD_DESCRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRT_CHILDREN),
+static WORD_DESCRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iption"),
         dictgen::InsensitiveStr::Ascii("iptions"),
@@ -169738,12 +169738,12 @@ pub static WORD_DESCRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=7,
 };
 
-static WORD_DESCRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRP_CHILDREN),
+static WORD_DESCRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -169761,12 +169761,12 @@ pub static WORD_DESCRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_DESCRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DESCRI_CHILDREN),
+static WORD_DESCRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DESCRI_CHILDREN),
     value: None,
 };
 
-static WORD_DESCRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DESCRI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DESCRIB_NODE),
     Some(&WORD_DESCRIC_NODE),
@@ -169795,12 +169795,12 @@ static WORD_DESCRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESCRIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIV_CHILDREN),
+static WORD_DESCRIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -169809,12 +169809,12 @@ pub static WORD_DESCRIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=3,
 };
 
-static WORD_DESCRIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIT_CHILDREN),
+static WORD_DESCRIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("or"),
@@ -169858,23 +169858,23 @@ pub static WORD_DESCRIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_DESCRIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIS_CHILDREN),
+static WORD_DESCRIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["describes"]],
     range: 1..=1,
 };
 
-static WORD_DESCRIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIP_CHILDREN),
+static WORD_DESCRIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cion"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -169942,12 +169942,12 @@ pub static WORD_DESCRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_DESCRIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIO_CHILDREN),
+static WORD_DESCRIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -169957,12 +169957,12 @@ pub static WORD_DESCRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_DESCRIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIM_CHILDREN),
+static WORD_DESCRIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inant"),
         dictgen::InsensitiveStr::Ascii("inate"),
@@ -169984,34 +169984,34 @@ pub static WORD_DESCRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=7,
 };
 
-static WORD_DESCRII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRII_CHILDREN),
+static WORD_DESCRII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRII_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bes")],
     values: &[&["describes"]],
     range: 3..=3,
 };
 
-static WORD_DESCRIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIE_CHILDREN),
+static WORD_DESCRIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIE_CHILDREN),
     value: Some(&["describe"]),
 };
 
-pub static WORD_DESCRIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DESCRIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIC_CHILDREN),
+static WORD_DESCRIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -170027,12 +170027,12 @@ pub static WORD_DESCRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_DESCRIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIB_CHILDREN),
+static WORD_DESCRIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIB_CHILDREN),
     value: Some(&["describe"]),
 };
 
-pub static WORD_DESCRIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bed"),
         dictgen::InsensitiveStr::Ascii("ibg"),
@@ -170054,12 +170054,12 @@ pub static WORD_DESCRIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_DESCRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRE_CHILDREN),
+static WORD_DESCRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -170083,34 +170083,34 @@ pub static WORD_DESCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_DESCRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRB_CHILDREN),
+static WORD_DESCRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["describes"]],
     range: 2..=2,
 };
 
-static WORD_DESCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCP_CHILDREN),
+static WORD_DESCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rition")],
     values: &[&["descriptions"]],
     range: 6..=6,
 };
 
-static WORD_DESCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCO_CHILDREN),
+static WORD_DESCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nstructed"),
         dictgen::InsensitiveStr::Ascii("ver"),
@@ -170128,12 +170128,12 @@ pub static WORD_DESCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DESCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCK_CHILDREN),
+static WORD_DESCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("top"),
         dictgen::InsensitiveStr::Ascii("tops"),
@@ -170142,12 +170142,12 @@ pub static WORD_DESCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DESCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCI_CHILDREN),
+static WORD_DESCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("bed"),
@@ -170217,12 +170217,12 @@ pub static WORD_DESCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DESCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCE_CHILDREN),
+static WORD_DESCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dent"),
         dictgen::InsensitiveStr::Ascii("ncing"),
@@ -170256,12 +170256,12 @@ pub static WORD_DESCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DESCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCC_CHILDREN),
+static WORD_DESCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hedules"),
         dictgen::InsensitiveStr::Ascii("ription"),
@@ -170270,12 +170270,12 @@ pub static WORD_DESCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_DESCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCA_CHILDREN),
+static WORD_DESCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llocate"),
         dictgen::InsensitiveStr::Ascii("llocated"),
@@ -170293,12 +170293,12 @@ pub static WORD_DESCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_DESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESA_CHILDREN),
+static WORD_DESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctivate"),
         dictgen::InsensitiveStr::Ascii("ctivated"),
@@ -170318,12 +170318,12 @@ pub static WORD_DESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_DER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DER_CHILDREN),
+static WORD_DER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DER_CHILDREN),
     value: None,
 };
 
-static WORD_DER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DERA_NODE),
     None,
     None,
@@ -170352,12 +170352,12 @@ static WORD_DER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERY_CHILDREN),
+static WORD_DERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pted"),
@@ -170367,12 +170367,12 @@ pub static WORD_DERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERV_CHILDREN),
+static WORD_DERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iative"),
         dictgen::InsensitiveStr::Ascii("iatives"),
@@ -170394,23 +170394,23 @@ pub static WORD_DERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERU_CHILDREN),
+static WORD_DERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gulation")],
     values: &[&["deregulation"]],
     range: 8..=8,
 };
 
-static WORD_DERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERT_CHILDREN),
+static WORD_DERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ails"),
         dictgen::InsensitiveStr::Ascii("ermine"),
@@ -170428,12 +170428,12 @@ pub static WORD_DERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERR_CHILDREN),
+static WORD_DERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ivatives"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -170443,12 +170443,12 @@ pub static WORD_DERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERP_CHILDREN),
+static WORD_DERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atologist"),
         dictgen::InsensitiveStr::Ascii("ivation"),
@@ -170458,12 +170458,12 @@ pub static WORD_DERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_DERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERO_CHILDREN),
+static WORD_DERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gatary"),
         dictgen::InsensitiveStr::Ascii("gatery"),
@@ -170483,23 +170483,23 @@ pub static WORD_DERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_DERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERN_CHILDREN),
+static WORD_DERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ormalization")],
     values: &[&["denormalization"]],
     range: 12..=12,
 };
 
-static WORD_DERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERM_CHILDREN),
+static WORD_DERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atalogist"),
         dictgen::InsensitiveStr::Ascii("atolagist"),
@@ -170527,12 +170527,12 @@ pub static WORD_DERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERI_CHILDREN),
+static WORD_DERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("air"),
         dictgen::InsensitiveStr::Ascii("atives"),
@@ -170588,12 +170588,12 @@ pub static WORD_DERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERG_CHILDREN),
+static WORD_DERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eistered"),
         dictgen::InsensitiveStr::Ascii("istration"),
@@ -170602,12 +170602,12 @@ pub static WORD_DERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_DERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERF_CHILDREN),
+static WORD_DERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erence"),
         dictgen::InsensitiveStr::Ascii("erencing"),
@@ -170627,12 +170627,12 @@ pub static WORD_DERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERE_CHILDREN),
+static WORD_DERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -170740,12 +170740,12 @@ pub static WORD_DERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_DERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERA_CHILDREN),
+static WORD_DERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("geable"),
         dictgen::InsensitiveStr::Ascii("gotory"),
@@ -170755,12 +170755,12 @@ pub static WORD_DERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEQ_CHILDREN),
+static WORD_DEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ued"),
         dictgen::InsensitiveStr::Ascii("ueing"),
@@ -170769,12 +170769,12 @@ pub static WORD_DEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_DEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEP_CHILDREN),
+static WORD_DEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEP_CHILDREN),
     value: None,
 };
 
-static WORD_DEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEPA_NODE),
     None,
     Some(&WORD_DEPC_NODE),
@@ -170803,12 +170803,12 @@ static WORD_DEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPS_CHILDREN),
+static WORD_DEPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("awn"),
         dictgen::InsensitiveStr::Ascii("erate"),
@@ -170830,12 +170830,12 @@ pub static WORD_DEPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DEPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPR_CHILDREN),
+static WORD_DEPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acated"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -170941,12 +170941,12 @@ pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DEPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPO_CHILDREN),
+static WORD_DEPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ist"),
         dictgen::InsensitiveStr::Ascii("isted"),
@@ -170992,12 +170992,12 @@ pub static WORD_DEPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DEPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPN_CHILDREN),
+static WORD_DEPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dant"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -171007,12 +171007,12 @@ pub static WORD_DEPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_DEPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPL_CHILDREN),
+static WORD_DEPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acements"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -171058,12 +171058,12 @@ pub static WORD_DEPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DEPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPI_CHILDREN),
+static WORD_DEPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("citng"),
         dictgen::InsensitiveStr::Ascii("citon"),
@@ -171083,12 +171083,12 @@ pub static WORD_DEPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DEPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEPE_CHILDREN),
+static WORD_DEPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEPE_CHILDREN),
     value: None,
 };
 
-static WORD_DEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DEPEC_NODE),
@@ -171117,12 +171117,12 @@ static WORD_DEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPER_CHILDREN),
+static WORD_DEPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -171146,12 +171146,12 @@ pub static WORD_DEPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_DEPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEPEN_CHILDREN),
+static WORD_DEPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEPEN_CHILDREN),
     value: None,
 };
 
-static WORD_DEPEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEPEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEPENA_NODE),
     None,
     Some(&WORD_DEPENC_NODE),
@@ -171180,45 +171180,45 @@ static WORD_DEPEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEPENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENT_CHILDREN),
+static WORD_DEPENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENT_CHILDREN),
     value: Some(&["depend"]),
 };
 
-pub static WORD_DEPENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DEPENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENN_CHILDREN),
+static WORD_DEPENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ding")],
     values: &[&["depending"]],
     range: 4..=4,
 };
 
-static WORD_DEPENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENI_CHILDREN),
+static WORD_DEPENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["depending", "deepening"]],
     range: 2..=2,
 };
 
-static WORD_DEPENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENE_CHILDREN),
+static WORD_DEPENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("decies"),
@@ -171264,12 +171264,12 @@ pub static WORD_DEPENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_DEPEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPEND_CHILDREN),
+static WORD_DEPEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancey"),
         dictgen::InsensitiveStr::Ascii("ancies"),
@@ -171389,12 +171389,12 @@ pub static WORD_DEPEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_DEPENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENC_CHILDREN),
+static WORD_DEPENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encies"),
         dictgen::InsensitiveStr::Ascii("ency"),
@@ -171418,34 +171418,34 @@ pub static WORD_DEPENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_DEPENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENA_CHILDREN),
+static WORD_DEPENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ncy")],
     values: &[&["dependency"]],
     range: 3..=3,
 };
 
-static WORD_DEPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPEL_CHILDREN),
+static WORD_DEPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["depleted"]],
     range: 3..=3,
 };
 
-static WORD_DEPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPED_CHILDREN),
+static WORD_DEPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encies"),
         dictgen::InsensitiveStr::Ascii("ency"),
@@ -171463,12 +171463,12 @@ pub static WORD_DEPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DEPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPEC_CHILDREN),
+static WORD_DEPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("reated"),
@@ -171478,12 +171478,12 @@ pub static WORD_DEPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DEPD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPD_CHILDREN),
+static WORD_DEPD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -171563,12 +171563,12 @@ pub static WORD_DEPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DEPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPC_CHILDREN),
+static WORD_DEPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ited"),
         dictgen::InsensitiveStr::Ascii("iting"),
@@ -171588,12 +171588,12 @@ pub static WORD_DEPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DEPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPA_CHILDREN),
+static WORD_DEPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndance"),
         dictgen::InsensitiveStr::Ascii("ndancies"),
@@ -171631,12 +171631,12 @@ pub static WORD_DEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_DEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEO_CHILDREN),
+static WORD_DEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cde"),
         dictgen::InsensitiveStr::Ascii("cded"),
@@ -171688,12 +171688,12 @@ pub static WORD_DEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_DEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEN_CHILDREN),
+static WORD_DEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("codings"),
         dictgen::InsensitiveStr::Ascii("egerate"),
@@ -171793,12 +171793,12 @@ pub static WORD_DEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_DEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEM_CHILDREN),
+static WORD_DEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEM_CHILDREN),
     value: None,
 };
 
-static WORD_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEMA_NODE),
     None,
     Some(&WORD_DEMC_NODE),
@@ -171827,45 +171827,45 @@ static WORD_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMU_CHILDREN),
+static WORD_DEMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dulator")],
     values: &[&["demodulator"]],
     range: 7..=7,
 };
 
-static WORD_DEMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMS_CHILDREN),
+static WORD_DEMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ond")],
     values: &[&["desmond"]],
     range: 3..=3,
 };
 
-static WORD_DEMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMP_CHILDREN),
+static WORD_DEMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hasize")],
     values: &[&["deemphasize"]],
     range: 6..=6,
 };
 
-static WORD_DEMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEMO_CHILDREN),
+static WORD_DEMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEMO_CHILDREN),
     value: None,
 };
 
-static WORD_DEMO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEMO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DEMOC_NODE),
@@ -171894,12 +171894,12 @@ static WORD_DEMO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEMOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOS_CHILDREN),
+static WORD_DEMOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntrably"),
         dictgen::InsensitiveStr::Ascii("ntrate"),
@@ -171931,23 +171931,23 @@ pub static WORD_DEMOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_DEMOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOR_CHILDREN),
+static WORD_DEMOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cracy")],
     values: &[&["democracy"]],
     range: 5..=5,
 };
 
-static WORD_DEMON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMON_CHILDREN),
+static WORD_DEMON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMON_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ination"),
@@ -172031,12 +172031,12 @@ pub static WORD_DEMON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_DEMOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOL_CHILDREN),
+static WORD_DEMOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("icion"),
@@ -172062,12 +172062,12 @@ pub static WORD_DEMOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DEMOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOG_CHILDREN),
+static WORD_DEMOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOG_CHILDREN),
     value: Some(&["demo"]),
 };
 
-pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rahic"),
         dictgen::InsensitiveStr::Ascii("rahpic"),
@@ -172095,23 +172095,23 @@ pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_DEMOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOD_CHILDREN),
+static WORD_DEMOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ualtor")],
     values: &[&["demodulator"]],
     range: 6..=6,
 };
 
-static WORD_DEMOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOC_CHILDREN),
+static WORD_DEMOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arcies"),
         dictgen::InsensitiveStr::Ascii("arcy"),
@@ -172157,23 +172157,23 @@ pub static WORD_DEMOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DEMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMM_CHILDREN),
+static WORD_DEMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("angled")],
     values: &[&["demangled"]],
     range: 6..=6,
 };
 
-static WORD_DEMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMI_CHILDREN),
+static WORD_DEMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nsion"),
         dictgen::InsensitiveStr::Ascii("nsional"),
@@ -172189,12 +172189,12 @@ pub static WORD_DEMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_DEME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEME_CHILDREN),
+static WORD_DEME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEME_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("naor"),
         dictgen::InsensitiveStr::Ascii("nor"),
@@ -172222,23 +172222,23 @@ pub static WORD_DEME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DEMC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMC_CHILDREN),
+static WORD_DEMC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orats")],
     values: &[&["democrats"]],
     range: 5..=5,
 };
 
-static WORD_DEMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMA_CHILDREN),
+static WORD_DEMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ind"),
         dictgen::InsensitiveStr::Ascii("md"),
@@ -172258,12 +172258,12 @@ pub static WORD_DEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEL_CHILDREN),
+static WORD_DEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEL_CHILDREN),
     value: None,
 };
 
-static WORD_DEL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DELA_NODE),
     None,
     Some(&WORD_DELC_NODE),
@@ -172292,23 +172292,23 @@ static WORD_DEL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DELY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELY_CHILDREN),
+static WORD_DELY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aing")],
     values: &[&["delaying"]],
     range: 4..=4,
 };
 
-static WORD_DELV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELV_CHILDREN),
+static WORD_DELV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ery"),
         dictgen::InsensitiveStr::Ascii("iered"),
@@ -172318,12 +172318,12 @@ pub static WORD_DELV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DELU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELU_CHILDREN),
+static WORD_DELU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sionally"),
         dictgen::InsensitiveStr::Ascii("sionnal"),
@@ -172333,12 +172333,12 @@ pub static WORD_DELU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_DELT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELT_CHILDREN),
+static WORD_DELT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELT_CHILDREN),
     value: Some(&["dealt"]),
 };
 
-pub static WORD_DELT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -172356,12 +172356,12 @@ pub static WORD_DELT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_DELP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELP_CHILDREN),
+static WORD_DELP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eted"),
         dictgen::InsensitiveStr::Ascii("orable"),
@@ -172383,34 +172383,34 @@ pub static WORD_DELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DELO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELO_CHILDREN),
+static WORD_DELO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pyment")],
     values: &[&["deployment"]],
     range: 6..=6,
 };
 
-static WORD_DELL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELL_CHILDREN),
+static WORD_DELL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ocate")],
     values: &[&["deallocate"]],
     range: 5..=5,
 };
 
-static WORD_DELI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DELI_CHILDREN),
+static WORD_DELI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DELI_CHILDREN),
     value: None,
 };
 
-static WORD_DELI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DELI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DELIB_NODE),
     Some(&WORD_DELIC_NODE),
@@ -172439,12 +172439,12 @@ static WORD_DELI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DELIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIV_CHILDREN),
+static WORD_DELIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ared"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -172482,23 +172482,23 @@ pub static WORD_DELIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DELIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIN_CHILDREN),
+static WORD_DELIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["unlink"]],
     range: 1..=1,
 };
 
-static WORD_DELIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIM_CHILDREN),
+static WORD_DELIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eted"),
         dictgen::InsensitiveStr::Ascii("eter"),
@@ -172578,12 +172578,12 @@ pub static WORD_DELIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_DELIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIG_CHILDREN),
+static WORD_DELIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("htlful"),
@@ -172593,12 +172593,12 @@ pub static WORD_DELIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DELIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIE_CHILDREN),
+static WORD_DELIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ver"),
         dictgen::InsensitiveStr::Ascii("vere"),
@@ -172624,23 +172624,23 @@ pub static WORD_DELIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DELIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIC_CHILDREN),
+static WORD_DELIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ous")],
     values: &[&["delicious"]],
     range: 3..=3,
 };
 
-static WORD_DELIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIB_CHILDREN),
+static WORD_DELIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("aretely"),
@@ -172680,12 +172680,12 @@ pub static WORD_DELIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DELG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELG_CHILDREN),
+static WORD_DELG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -172709,12 +172709,12 @@ pub static WORD_DELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DELF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELF_CHILDREN),
+static WORD_DELF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ect"),
@@ -172724,12 +172724,12 @@ pub static WORD_DELF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DELE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELE_CHILDREN),
+static WORD_DELE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arship"),
         dictgen::InsensitiveStr::Ascii("arships"),
@@ -172797,12 +172797,12 @@ pub static WORD_DELE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DELC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELC_CHILDREN),
+static WORD_DELC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("arations"),
@@ -172826,12 +172826,12 @@ pub static WORD_DELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DELA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELA_CHILDREN),
+static WORD_DELA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ership"),
         dictgen::InsensitiveStr::Ascii("erships"),
@@ -172873,12 +172873,12 @@ pub static WORD_DELA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEK_CHILDREN),
+static WORD_DEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ete"),
         dictgen::InsensitiveStr::Ascii("eted"),
@@ -172904,12 +172904,12 @@ pub static WORD_DEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_DEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEI_CHILDREN),
+static WORD_DEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fnately"),
         dictgen::InsensitiveStr::Ascii("fne"),
@@ -172991,12 +172991,12 @@ pub static WORD_DEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_DEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEH_CHILDREN),
+static WORD_DEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ydraded"),
         dictgen::InsensitiveStr::Ascii("yrdated"),
@@ -173006,12 +173006,12 @@ pub static WORD_DEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_DEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEG_CHILDREN),
+static WORD_DEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arde"),
         dictgen::InsensitiveStr::Ascii("arded"),
@@ -173125,12 +173125,12 @@ pub static WORD_DEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_DEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEF_CHILDREN),
+static WORD_DEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEF_CHILDREN),
     value: None,
 };
 
-static WORD_DEF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEFA_NODE),
     None,
     None,
@@ -173159,23 +173159,23 @@ static WORD_DEF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEFY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFY_CHILDREN),
+static WORD_DEFY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ning")],
     values: &[&["defining"]],
     range: 4..=4,
 };
 
-static WORD_DEFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFU_CHILDREN),
+static WORD_DEFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alt"),
         dictgen::InsensitiveStr::Ascii("altdict"),
@@ -173199,45 +173199,45 @@ pub static WORD_DEFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DEFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFR_CHILDREN),
+static WORD_DEFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("agmenation")],
     values: &[&["defragmentation"]],
     range: 10..=10,
 };
 
-static WORD_DEFQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFQ_CHILDREN),
+static WORD_DEFQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ault")],
     values: &[&["default"]],
     range: 4..=4,
 };
 
-static WORD_DEFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFO_CHILDREN),
+static WORD_DEFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("re")],
     values: &[&["before"]],
     range: 2..=2,
 };
 
-static WORD_DEFN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFN_CHILDREN),
+static WORD_DEFN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("iately"),
@@ -173259,12 +173259,12 @@ pub static WORD_DEFN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DEFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFL_CHILDREN),
+static WORD_DEFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("action"),
         dictgen::InsensitiveStr::Ascii("atin"),
@@ -173288,12 +173288,12 @@ pub static WORD_DEFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DEFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEFI_CHILDREN),
+static WORD_DEFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEFI_CHILDREN),
     value: None,
 };
 
-static WORD_DEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEFI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEFIA_NODE),
     Some(&WORD_DEFIB_NODE),
     Some(&WORD_DEFIC_NODE),
@@ -173322,23 +173322,23 @@ static WORD_DEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEFIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIV_CHILDREN),
+static WORD_DEFIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["derived"]],
     range: 2..=2,
 };
 
-static WORD_DEFIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIT_CHILDREN),
+static WORD_DEFIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enly"),
         dictgen::InsensitiveStr::Ascii("inly"),
@@ -173360,12 +173360,12 @@ pub static WORD_DEFIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DEFIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIS_CHILDREN),
+static WORD_DEFIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hant"),
         dictgen::InsensitiveStr::Ascii("hantly"),
@@ -173374,12 +173374,12 @@ pub static WORD_DEFIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DEFIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEFIN_CHILDREN),
+static WORD_DEFIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEFIN_CHILDREN),
     value: Some(&["define"]),
 };
 
-static WORD_DEFIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEFIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEFINA_NODE),
     None,
     None,
@@ -173408,23 +173408,23 @@ static WORD_DEFIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEFINU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINU_CHILDREN),
+static WORD_DEFINU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tely")],
     values: &[&["definitely"]],
     range: 4..=4,
 };
 
-static WORD_DEFINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINT_CHILDREN),
+static WORD_DEFINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINT_CHILDREN),
     value: Some(&["definite", "define"]),
 };
 
-pub static WORD_DEFINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aley"),
         dictgen::InsensitiveStr::Ascii("aly"),
@@ -173462,34 +173462,34 @@ pub static WORD_DEFINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_DEFINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINS_CHILDREN),
+static WORD_DEFINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINS_CHILDREN),
     value: Some(&["defines", "define"]),
 };
 
-pub static WORD_DEFINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tely")],
     values: &[&["definitely"]],
     range: 4..=4,
 };
 
-static WORD_DEFINO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINO_CHILDREN),
+static WORD_DEFINO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tely")],
     values: &[&["definitely"]],
     range: 4..=4,
 };
 
-static WORD_DEFINN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINN_CHILDREN),
+static WORD_DEFINN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ition"),
@@ -173498,23 +173498,23 @@ pub static WORD_DEFINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_DEFINM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINM_CHILDREN),
+static WORD_DEFINM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["defined"]],
     range: 2..=2,
 };
 
-static WORD_DEFINL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINL_CHILDREN),
+static WORD_DEFINL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tely"),
         dictgen::InsensitiveStr::Ascii("tey"),
@@ -173523,23 +173523,23 @@ pub static WORD_DEFINL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_DEFINJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINJ_CHILDREN),
+static WORD_DEFINJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tely")],
     values: &[&["definitely"]],
     range: 4..=4,
 };
 
-static WORD_DEFINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINI_CHILDREN),
+static WORD_DEFINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -173665,12 +173665,12 @@ pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_DEFINE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINE_CHILDREN),
+static WORD_DEFINE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("as"),
@@ -173722,12 +173722,12 @@ pub static WORD_DEFINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_DEFIND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIND_CHILDREN),
+static WORD_DEFIND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIND_CHILDREN),
     value: Some(&["defined", "defund"]),
 };
 
-pub static WORD_DEFIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -173741,12 +173741,12 @@ pub static WORD_DEFIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_DEFINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINA_CHILDREN),
+static WORD_DEFINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("etly"),
@@ -173812,23 +173812,23 @@ pub static WORD_DEFINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_DEFII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFII_CHILDREN),
+static WORD_DEFII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFII_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ntely")],
     values: &[&["definitely"]],
     range: 5..=5,
 };
 
-static WORD_DEFIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIE_CHILDREN),
+static WORD_DEFIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nd"),
@@ -173839,12 +173839,12 @@ pub static WORD_DEFIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_DEFIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIC_CHILDREN),
+static WORD_DEFIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ately"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -173884,23 +173884,23 @@ pub static WORD_DEFIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DEFIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIB_CHILDREN),
+static WORD_DEFIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ately")],
     values: &[&["definitely"]],
     range: 5..=5,
 };
 
-static WORD_DEFIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIA_CHILDREN),
+static WORD_DEFIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("netly"),
         dictgen::InsensitiveStr::Ascii("nlty"),
@@ -173916,12 +173916,12 @@ pub static WORD_DEFIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_DEFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFF_CHILDREN),
+static WORD_DEFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("aulted"),
@@ -173969,12 +173969,12 @@ pub static WORD_DEFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DEFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFE_CHILDREN),
+static WORD_DEFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("aulted"),
@@ -174098,12 +174098,12 @@ pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DEFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFA_CHILDREN),
+static WORD_DEFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cation"),
         dictgen::InsensitiveStr::Ascii("il"),
@@ -174233,12 +174233,12 @@ pub static WORD_DEFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEE_CHILDREN),
+static WORD_DEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("corator"),
         dictgen::InsensitiveStr::Ascii("emed"),
@@ -174268,12 +174268,12 @@ pub static WORD_DEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DED_CHILDREN),
+static WORD_DED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DED_CHILDREN),
     value: Some(&["dead"]),
 };
 
-pub static WORD_DED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("ecated"),
@@ -174365,12 +174365,12 @@ pub static WORD_DED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_DEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEC_CHILDREN),
+static WORD_DEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEC_CHILDREN),
     value: None,
 };
 
-static WORD_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DECA_NODE),
     None,
     Some(&WORD_DECC_NODE),
@@ -174399,12 +174399,12 @@ static WORD_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DECY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECY_CHILDREN),
+static WORD_DECY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pher"),
         dictgen::InsensitiveStr::Ascii("phered"),
@@ -174415,12 +174415,12 @@ pub static WORD_DECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECU_CHILDREN),
+static WORD_DECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tables"),
@@ -174429,12 +174429,12 @@ pub static WORD_DECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_DECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECT_CHILDREN),
+static WORD_DECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ecte"),
@@ -174462,12 +174462,12 @@ pub static WORD_DECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DECS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECS_CHILDREN),
+static WORD_DECS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cription"),
         dictgen::InsensitiveStr::Ascii("end"),
@@ -174501,12 +174501,12 @@ pub static WORD_DECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECR_CHILDREN),
+static WORD_DECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aesing"),
         dictgen::InsensitiveStr::Ascii("asing"),
@@ -174618,12 +174618,12 @@ pub static WORD_DECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DECP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECP_CHILDREN),
+static WORD_DECP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etion"),
         dictgen::InsensitiveStr::Ascii("etive"),
@@ -174633,12 +174633,12 @@ pub static WORD_DECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DECO_CHILDREN),
+static WORD_DECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DECO_CHILDREN),
     value: None,
 };
 
-static WORD_DECO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DECO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DECOA_NODE),
     None,
     Some(&WORD_DECOC_NODE),
@@ -174667,23 +174667,23 @@ static WORD_DECO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DECOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOT_CHILDREN),
+static WORD_DECOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ations")],
     values: &[&["decorations"]],
     range: 6..=6,
 };
 
-static WORD_DECOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOS_CHILDREN),
+static WORD_DECOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -174705,12 +174705,12 @@ pub static WORD_DECOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_DECOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOR_CHILDREN),
+static WORD_DECOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -174762,12 +174762,12 @@ pub static WORD_DECOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DECOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOP_CHILDREN),
+static WORD_DECOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ose"),
         dictgen::InsensitiveStr::Ascii("oses"),
@@ -174777,12 +174777,12 @@ pub static WORD_DECOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DECON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECON_CHILDREN),
+static WORD_DECON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECON_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -174812,12 +174812,12 @@ pub static WORD_DECON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DECOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOM_CHILDREN),
+static WORD_DECOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iler"),
         dictgen::InsensitiveStr::Ascii("issioned"),
@@ -174889,12 +174889,12 @@ pub static WORD_DECOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DECOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOD_CHILDREN),
+static WORD_DECOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -174904,12 +174904,12 @@ pub static WORD_DECOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DECOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOC_CHILDREN),
+static WORD_DECOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -174931,34 +174931,34 @@ pub static WORD_DECOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DECOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOA_CHILDREN),
+static WORD_DECOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rtions")],
     values: &[&["decoration"]],
     range: 6..=6,
 };
 
-static WORD_DECM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECM_CHILDREN),
+static WORD_DECM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eber")],
     values: &[&["december"]],
     range: 4..=4,
 };
 
-static WORD_DECL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECL_CHILDREN),
+static WORD_DECL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("air"),
         dictgen::InsensitiveStr::Ascii("aire"),
@@ -175084,12 +175084,12 @@ pub static WORD_DECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECI_CHILDREN),
+static WORD_DECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aml"),
         dictgen::InsensitiveStr::Ascii("amls"),
@@ -175173,12 +175173,12 @@ pub static WORD_DECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECE_CHILDREN),
+static WORD_DECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("laration"),
@@ -175238,23 +175238,23 @@ pub static WORD_DECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DECD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECD_CHILDREN),
+static WORD_DECD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oing")],
     values: &[&["decoding"]],
     range: 4..=4,
 };
 
-static WORD_DECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECC_CHILDREN),
+static WORD_DECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elerate"),
         dictgen::InsensitiveStr::Ascii("elerated"),
@@ -175280,12 +175280,12 @@ pub static WORD_DECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECA_CHILDREN),
+static WORD_DECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ffinated"),
         dictgen::InsensitiveStr::Ascii("lare"),
@@ -175325,12 +175325,12 @@ pub static WORD_DECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEB_CHILDREN),
+static WORD_DEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ateable"),
@@ -175428,12 +175428,12 @@ pub static WORD_DEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_DEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEA_CHILDREN),
+static WORD_DEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEA_CHILDREN),
     value: None,
 };
 
-static WORD_DEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DEAC_NODE),
@@ -175462,12 +175462,12 @@ static WORD_DEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAU_CHILDREN),
+static WORD_DEAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lt"),
         dictgen::InsensitiveStr::Ascii("lts"),
@@ -175477,12 +175477,12 @@ pub static WORD_DEAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_DEAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAT_CHILDREN),
+static WORD_DEAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ail"),
         dictgen::InsensitiveStr::Ascii("ails"),
@@ -175540,23 +175540,23 @@ pub static WORD_DEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DEAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAS_CHILDREN),
+static WORD_DEAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sering")],
     values: &[&["deasserting"]],
     range: 6..=6,
 };
 
-static WORD_DEAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAP_CHILDREN),
+static WORD_DEAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("th"),
         dictgen::InsensitiveStr::Ascii("ths"),
@@ -175565,12 +175565,12 @@ pub static WORD_DEAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_DEAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAM_CHILDREN),
+static WORD_DEAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("and"),
         dictgen::InsensitiveStr::Ascii("anding"),
@@ -175634,12 +175634,12 @@ pub static WORD_DEAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DEAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAL_CHILDREN),
+static WORD_DEAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("erhsip"),
@@ -175673,12 +175673,12 @@ pub static WORD_DEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DEAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAK_CHILDREN),
+static WORD_DEAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tivate"),
         dictgen::InsensitiveStr::Ascii("tivated"),
@@ -175687,12 +175687,12 @@ pub static WORD_DEAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_DEAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAI_CHILDREN),
+static WORD_DEAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -175701,23 +175701,23 @@ pub static WORD_DEAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_DEAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAH_CHILDREN),
+static WORD_DEAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tly")],
     values: &[&["deathly"]],
     range: 3..=3,
 };
 
-static WORD_DEAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAF_CHILDREN),
+static WORD_DEAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("eted"),
@@ -175739,23 +175739,23 @@ pub static WORD_DEAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DEAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAE_CHILDREN),
+static WORD_DEAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mon")],
     values: &[&["daemon"]],
     range: 3..=3,
 };
 
-static WORD_DEAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAD_CHILDREN),
+static WORD_DEAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfit"),
         dictgen::InsensitiveStr::Ascii("lfits"),
@@ -175779,12 +175779,12 @@ pub static WORD_DEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DEAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAC_CHILDREN),
+static WORD_DEAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itivation"),
         dictgen::InsensitiveStr::Ascii("itvated"),
@@ -175822,12 +175822,12 @@ pub static WORD_DEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DD_CHILDREN),
+static WORD_DD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elete"),
         dictgen::InsensitiveStr::Ascii("evices"),
@@ -175851,12 +175851,12 @@ pub static WORD_DD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_DC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DC_CHILDREN),
+static WORD_DC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hp"),
         dictgen::InsensitiveStr::Ascii("ok"),
@@ -175888,12 +175888,12 @@ pub static WORD_DC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DB_CHILDREN),
+static WORD_DB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eian"),
@@ -175902,12 +175902,12 @@ pub static WORD_DB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_DA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DA_CHILDREN),
+static WORD_DA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DA_CHILDREN),
     value: None,
 };
 
-static WORD_DA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DAA_NODE),
     Some(&WORD_DAB_NODE),
     Some(&WORD_DAC_NODE),
@@ -175936,45 +175936,45 @@ static WORD_DA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAY_CHILDREN),
+static WORD_DAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bue")],
     values: &[&["debut"]],
     range: 3..=3,
 };
 
-static WORD_DAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAW_CHILDREN),
+static WORD_DAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rves")],
     values: &[&["dwarves"]],
     range: 4..=4,
 };
 
-static WORD_DAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAV_CHILDREN),
+static WORD_DAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("antage")],
     values: &[&["advantage"]],
     range: 6..=6,
 };
 
-static WORD_DAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAU_CHILDREN),
+static WORD_DAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gher"),
         dictgen::InsensitiveStr::Ascii("ghterbord"),
@@ -175996,12 +175996,12 @@ pub static WORD_DAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_DAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DAT_CHILDREN),
+static WORD_DAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DAT_CHILDREN),
     value: None,
 };
 
-static WORD_DAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DATA_NODE),
     Some(&WORD_DATB_NODE),
     None,
@@ -176030,23 +176030,23 @@ static WORD_DAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DATY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATY_CHILDREN),
+static WORD_DATY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATY_CHILDREN),
     value: Some(&["data", "date"]),
 };
 
-pub static WORD_DATY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATS_CHILDREN),
+static WORD_DATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -176055,23 +176055,23 @@ pub static WORD_DATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_DATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATR_CHILDREN),
+static WORD_DATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("abase")],
     values: &[&["database"]],
     range: 5..=5,
 };
 
-static WORD_DATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATE_CHILDREN),
+static WORD_DATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("base"),
@@ -176097,12 +176097,12 @@ pub static WORD_DATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DATB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATB_CHILDREN),
+static WORD_DATB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ases"),
@@ -176111,12 +176111,12 @@ pub static WORD_DATB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATA_CHILDREN),
+static WORD_DATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baase"),
         dictgen::InsensitiveStr::Ascii("baases"),
@@ -176228,12 +176228,12 @@ pub static WORD_DATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_DAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAS_CHILDREN),
+static WORD_DAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("board"),
         dictgen::InsensitiveStr::Ascii("boards"),
@@ -176271,12 +176271,12 @@ pub static WORD_DAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_DAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAR_CHILDREN),
+static WORD_DAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cula"),
         dictgen::InsensitiveStr::Ascii("denelles"),
@@ -176298,23 +176298,23 @@ pub static WORD_DAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_DAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAP_CHILDREN),
+static WORD_DAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("licating")],
     values: &[&["duplicating"]],
     range: 8..=8,
 };
 
-static WORD_DAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAN_CHILDREN),
+static WORD_DAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceing"),
         dictgen::InsensitiveStr::Ascii("didates"),
@@ -176340,12 +176340,12 @@ pub static WORD_DAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_DAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAM_CHILDREN),
+static WORD_DAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amge"),
         dictgen::InsensitiveStr::Ascii("amged"),
@@ -176387,12 +176387,12 @@ pub static WORD_DAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_DAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAL_CHILDREN),
+static WORD_DAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egate"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -176410,23 +176410,23 @@ pub static WORD_DAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_DAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAK_CHILDREN),
+static WORD_DAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["take"]],
     range: 1..=1,
 };
 
-static WORD_DAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAI_CHILDREN),
+static WORD_DAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logue"),
         dictgen::InsensitiveStr::Ascii("mond"),
@@ -176437,12 +176437,12 @@ pub static WORD_DAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_DAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAH_CHILDREN),
+static WORD_DAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("board"),
         dictgen::InsensitiveStr::Ascii("boards"),
@@ -176452,23 +176452,23 @@ pub static WORD_DAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_DAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAG_CHILDREN),
+static WORD_DAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ners")],
     values: &[&["dangers"]],
     range: 4..=4,
 };
 
-static WORD_DAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAF_CHILDREN),
+static WORD_DAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("aults"),
@@ -176488,12 +176488,12 @@ pub static WORD_DAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_DAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAE_CHILDREN),
+static WORD_DAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -176507,23 +176507,23 @@ pub static WORD_DAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAD_CHILDREN),
+static WORD_DAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lock")],
     values: &[&["deadlock"]],
     range: 4..=4,
 };
 
-static WORD_DAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAC_CHILDREN),
+static WORD_DAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kery"),
         dictgen::InsensitiveStr::Ascii("laration"),
@@ -176533,12 +176533,12 @@ pub static WORD_DAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_DAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAB_CHILDREN),
+static WORD_DAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ilitating"),
@@ -176549,23 +176549,23 @@ pub static WORD_DAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAA_CHILDREN),
+static WORD_DAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAA_CHILDREN),
     value: Some(&["data"]),
 };
 
-pub static WORD_DAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tsheet")],
     values: &[&["datasheet"]],
     range: 6..=6,
 };
 
-static WORD_C_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_C_CHILDREN),
+static WORD_C_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_C_CHILDREN),
     value: None,
 };
 
-static WORD_C_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_C_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CA_NODE),
     None,
     Some(&WORD_CC_NODE),
@@ -176594,23 +176594,23 @@ static WORD_C_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CZ_NODE),
 ];
 
-static WORD_CZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CZ_CHILDREN),
+static WORD_CZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("echoslavakia")],
     values: &[&["czechoslovakia"]],
     range: 12..=12,
 };
 
-static WORD_CY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CY_CHILDREN),
+static WORD_CY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andie"),
         dictgen::InsensitiveStr::Ascii("cic"),
@@ -176744,34 +176744,34 @@ pub static WORD_CY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_CX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CX_CHILDREN),
+static WORD_CX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CX_CHILDREN),
     value: None,
 };
 
-pub static WORD_CX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("an")],
     values: &[&["cyan"]],
     range: 2..=2,
 };
 
-static WORD_CV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CV_CHILDREN),
+static WORD_CV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ignore")],
     values: &[&["cvsignore"]],
     range: 6..=6,
 };
 
-static WORD_CU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CU_CHILDREN),
+static WORD_CU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CU_CHILDREN),
     value: None,
 };
 
-static WORD_CU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CUA_NODE),
     Some(&WORD_CUB_NODE),
     None,
@@ -176800,12 +176800,12 @@ static WORD_CU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CUZ_NODE),
 ];
 
-static WORD_CUZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUZ_CHILDREN),
+static WORD_CUZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tomizable"),
         dictgen::InsensitiveStr::Ascii("tomization"),
@@ -176831,12 +176831,12 @@ pub static WORD_CUZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=11,
 };
 
-static WORD_CUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUV_CHILDREN),
+static WORD_CUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -176850,12 +176850,12 @@ pub static WORD_CUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_CUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUU_CHILDREN),
+static WORD_CUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rently"),
         dictgen::InsensitiveStr::Ascii("rrent"),
@@ -176865,12 +176865,12 @@ pub static WORD_CUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_CUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUT_CHILDREN),
+static WORD_CUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("om"),
@@ -176908,12 +176908,12 @@ pub static WORD_CUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CUS_CHILDREN),
+static WORD_CUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CUS_CHILDREN),
     value: None,
 };
 
-static WORD_CUS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CUS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -176942,12 +176942,12 @@ static WORD_CUS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CUST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CUST_CHILDREN),
+static WORD_CUST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CUST_CHILDREN),
     value: None,
 };
 
-static WORD_CUST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CUST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CUSTA_NODE),
     None,
     Some(&WORD_CUSTC_NODE),
@@ -176976,12 +176976,12 @@ static WORD_CUST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CUSTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTU_CHILDREN),
+static WORD_CUSTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mer"),
@@ -177003,12 +177003,12 @@ pub static WORD_CUSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CUSTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTO_CHILDREN),
+static WORD_CUSTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emr"),
         dictgen::InsensitiveStr::Ascii("emrs"),
@@ -177126,23 +177126,23 @@ pub static WORD_CUSTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CUSTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTM_CHILDREN),
+static WORD_CUSTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["customer"]],
     range: 2..=2,
 };
 
-static WORD_CUSTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTI_CHILDREN),
+static WORD_CUSTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mizable"),
         dictgen::InsensitiveStr::Ascii("mized"),
@@ -177151,12 +177151,12 @@ pub static WORD_CUSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CUSTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTC_CHILDREN),
+static WORD_CUSTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ene"),
         dictgen::InsensitiveStr::Ascii("enes"),
@@ -177165,12 +177165,12 @@ pub static WORD_CUSTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CUSTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTA_CHILDREN),
+static WORD_CUSTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mizable"),
         dictgen::InsensitiveStr::Ascii("mized"),
@@ -177186,12 +177186,12 @@ pub static WORD_CUSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CUSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSS_CHILDREN),
+static WORD_CUSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("tom"),
@@ -177217,12 +177217,12 @@ pub static WORD_CUSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_CUSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSO_CHILDREN),
+static WORD_CUSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mers"),
@@ -177242,12 +177242,12 @@ pub static WORD_CUSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CUSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSI_CHILDREN),
+static WORD_CUSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ne"),
         dictgen::InsensitiveStr::Ascii("nes"),
@@ -177256,12 +177256,12 @@ pub static WORD_CUSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CUSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSH_CHILDREN),
+static WORD_CUSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ins"),
@@ -177270,12 +177270,12 @@ pub static WORD_CUSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CUR_CHILDREN),
+static WORD_CUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CUR_CHILDREN),
     value: None,
 };
 
-static WORD_CUR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CUR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CURA_NODE),
     None,
     Some(&WORD_CURC_NODE),
@@ -177304,12 +177304,12 @@ static WORD_CUR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CURV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURV_CHILDREN),
+static WORD_CURV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asious"),
         dictgen::InsensitiveStr::Ascii("atrue"),
@@ -177325,12 +177325,12 @@ pub static WORD_CURV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CURT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURT_CHILDREN),
+static WORD_CURT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esy"),
         dictgen::InsensitiveStr::Ascii("eus"),
@@ -177346,12 +177346,12 @@ pub static WORD_CURT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CURS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURS_CHILDREN),
+static WORD_CURS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("ader"),
@@ -177377,12 +177377,12 @@ pub static WORD_CURS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CURR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CURR_CHILDREN),
+static WORD_CURR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CURR_CHILDREN),
     value: None,
 };
 
-static WORD_CURR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CURR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CURRA_NODE),
     None,
     None,
@@ -177411,12 +177411,12 @@ static WORD_CURR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CURRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRU_CHILDREN),
+static WORD_CURRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -177442,12 +177442,12 @@ pub static WORD_CURRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CURRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRR_CHILDREN),
+static WORD_CURRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ency"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -177457,12 +177457,12 @@ pub static WORD_CURRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CURRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRO_CHILDREN),
+static WORD_CURRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ption"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -177471,12 +177471,12 @@ pub static WORD_CURRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CURRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRN_CHILDREN),
+static WORD_CURRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etly"),
@@ -177487,12 +177487,12 @@ pub static WORD_CURRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CURRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRI_CHILDREN),
+static WORD_CURRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("culem"),
         dictgen::InsensitiveStr::Ascii("culim"),
@@ -177512,12 +177512,12 @@ pub static WORD_CURRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CURRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRE_CHILDREN),
+static WORD_CURRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cnies"),
         dictgen::InsensitiveStr::Ascii("cny"),
@@ -177601,12 +177601,12 @@ pub static WORD_CURRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CURRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRA_CHILDREN),
+static WORD_CURRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncies"),
         dictgen::InsensitiveStr::Ascii("te"),
@@ -177615,12 +177615,12 @@ pub static WORD_CURRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CURN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURN_CHILDREN),
+static WORD_CURN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("els"),
@@ -177630,12 +177630,12 @@ pub static WORD_CURN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CURI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURI_CHILDREN),
+static WORD_CURI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("culum"),
         dictgen::InsensitiveStr::Ascii("ocity"),
@@ -177665,12 +177665,12 @@ pub static WORD_CURI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CURE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURE_CHILDREN),
+static WORD_CURE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ful"),
         dictgen::InsensitiveStr::Ascii("fully"),
@@ -177704,12 +177704,12 @@ pub static WORD_CURE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CURC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURC_CHILDREN),
+static WORD_CURC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -177741,12 +177741,12 @@ pub static WORD_CURC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CURA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURA_CHILDREN),
+static WORD_CURA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("geous"),
@@ -177757,12 +177757,12 @@ pub static WORD_CURA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUP_CHILDREN),
+static WORD_CUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baord"),
         dictgen::InsensitiveStr::Ascii("boad"),
@@ -177782,12 +177782,12 @@ pub static WORD_CUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUN_CHILDREN),
+static WORD_CUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("curency"),
         dictgen::InsensitiveStr::Ascii("current"),
@@ -177811,12 +177811,12 @@ pub static WORD_CUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_CUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUM_CHILDREN),
+static WORD_CUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bersomem"),
         dictgen::InsensitiveStr::Ascii("bersone"),
@@ -177854,12 +177854,12 @@ pub static WORD_CUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_CUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUL_CHILDREN),
+static WORD_CUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("iminating"),
@@ -177903,23 +177903,23 @@ pub static WORD_CUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_CUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUI_CHILDREN),
+static WORD_CUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("leoga")],
     values: &[&["cuileog"]],
     range: 5..=5,
 };
 
-static WORD_CUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUE_CHILDREN),
+static WORD_CUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stion"),
         dictgen::InsensitiveStr::Ascii("stionable"),
@@ -177935,12 +177935,12 @@ pub static WORD_CUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_CUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUD_CHILDREN),
+static WORD_CUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dels"),
         dictgen::InsensitiveStr::Ascii("dleys"),
@@ -177949,12 +177949,12 @@ pub static WORD_CUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_CUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUB_CHILDREN),
+static WORD_CUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("burd"),
         dictgen::InsensitiveStr::Ascii("burds"),
@@ -177972,12 +177972,12 @@ pub static WORD_CUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_CUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUA_CHILDREN),
+static WORD_CUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("casian"),
         dictgen::InsensitiveStr::Ascii("sality"),
@@ -178001,12 +178001,12 @@ pub static WORD_CUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CT_CHILDREN),
+static WORD_CT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eate"),
         dictgen::InsensitiveStr::Ascii("eateing"),
@@ -178050,12 +178050,12 @@ pub static WORD_CT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_CS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CS_CHILDREN),
+static WORD_CS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -178066,12 +178066,12 @@ pub static WORD_CS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_CR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CR_CHILDREN),
+static WORD_CR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CR_CHILDREN),
     value: None,
 };
 
-static WORD_CR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CRA_NODE),
     None,
     None,
@@ -178100,12 +178100,12 @@ static WORD_CR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRY_CHILDREN),
+static WORD_CRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pitc"),
         dictgen::InsensitiveStr::Ascii("pric"),
@@ -178159,12 +178159,12 @@ pub static WORD_CRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_CRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRU_CHILDREN),
+static WORD_CRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asder"),
         dictgen::InsensitiveStr::Ascii("ciaal"),
@@ -178240,12 +178240,12 @@ pub static WORD_CRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_CRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRT_CHILDREN),
+static WORD_CRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -178261,12 +178261,12 @@ pub static WORD_CRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_CRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRS_CHILDREN),
+static WORD_CRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ytal"),
         dictgen::InsensitiveStr::Ascii("ytalline"),
@@ -178290,34 +178290,34 @@ pub static WORD_CRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=13,
 };
 
-static WORD_CRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRR_CHILDREN),
+static WORD_CRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("espond")],
     values: &[&["correspond"]],
     range: 6..=6,
 };
 
-static WORD_CRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRP_CHILDREN),
+static WORD_CRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ytic")],
     values: &[&["cryptic"]],
     range: 4..=4,
 };
 
-static WORD_CRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRO_CHILDREN),
+static WORD_CRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atioa"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -178409,12 +178409,12 @@ pub static WORD_CRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_CRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CRI_CHILDREN),
+static WORD_CRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CRI_CHILDREN),
     value: None,
 };
 
-static WORD_CRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CRI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CRIC_NODE),
@@ -178443,12 +178443,12 @@ static WORD_CRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CRIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CRIT_CHILDREN),
+static WORD_CRIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CRIT_CHILDREN),
     value: None,
 };
 
-static WORD_CRIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CRIT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CRITC_NODE),
@@ -178477,12 +178477,12 @@ static WORD_CRIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CRITQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRITQ_CHILDREN),
+static WORD_CRITQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRITQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRITQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRITQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ue"),
         dictgen::InsensitiveStr::Ascii("ued"),
@@ -178492,12 +178492,12 @@ pub static WORD_CRITQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_CRITI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRITI_CHILDREN),
+static WORD_CRITI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRITI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRITI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("call"),
@@ -178631,12 +178631,12 @@ pub static WORD_CRITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CRITE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRITE_CHILDREN),
+static WORD_CRITE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRITE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRITE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("ra"),
@@ -178654,12 +178654,12 @@ pub static WORD_CRITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_CRITC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRITC_CHILDREN),
+static WORD_CRITC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRITC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRITC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRITC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -178679,12 +178679,12 @@ pub static WORD_CRITC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CRIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIR_CHILDREN),
+static WORD_CRIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -178694,12 +178694,12 @@ pub static WORD_CRIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CRIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIP_CHILDREN),
+static WORD_CRIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -178708,12 +178708,12 @@ pub static WORD_CRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CRIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIN_CHILDREN),
+static WORD_CRIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gely"),
         dictgen::InsensitiveStr::Ascii("gery"),
@@ -178743,12 +178743,12 @@ pub static WORD_CRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_CRIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIM_CHILDREN),
+static WORD_CRIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anally"),
         dictgen::InsensitiveStr::Ascii("inalty"),
@@ -178764,23 +178764,23 @@ pub static WORD_CRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CRIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIG_CHILDREN),
+static WORD_CRIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("neworthy")],
     values: &[&["cringeworthy"]],
     range: 8..=8,
 };
 
-static WORD_CRIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIC_CHILDREN),
+static WORD_CRIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ital"),
         dictgen::InsensitiveStr::Ascii("itally"),
@@ -178808,23 +178808,23 @@ pub static WORD_CRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CRH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRH_CHILDREN),
+static WORD_CRH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("istmas")],
     values: &[&["christmas"]],
     range: 6..=6,
 };
 
-static WORD_CRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CRE_CHILDREN),
+static WORD_CRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CRE_CHILDREN),
     value: None,
 };
 
-static WORD_CRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CREA_NODE),
     None,
     None,
@@ -178853,34 +178853,34 @@ static WORD_CRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CREW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREW_CHILDREN),
+static WORD_CREW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREW_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sant")],
     values: &[&["croissant"]],
     range: 4..=4,
 };
 
-static WORD_CREU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREU_CHILDREN),
+static WORD_CREU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lty")],
     values: &[&["cruelty"]],
     range: 3..=3,
 };
 
-static WORD_CRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRET_CHILDREN),
+static WORD_CRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRET_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -178918,12 +178918,12 @@ pub static WORD_CRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRES_CHILDREN),
+static WORD_CRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -178933,23 +178933,23 @@ pub static WORD_CRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREN_CHILDREN),
+static WORD_CREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ditals")],
     values: &[&["credentials"]],
     range: 6..=6,
 };
 
-static WORD_CREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREE_CHILDREN),
+static WORD_CREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ates"),
@@ -178971,12 +178971,12 @@ pub static WORD_CREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CRED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRED_CHILDREN),
+static WORD_CRED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("encials"),
@@ -179024,12 +179024,12 @@ pub static WORD_CRED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREA_CHILDREN),
+static WORD_CREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("cionism"),
@@ -179139,23 +179139,23 @@ pub static WORD_CREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CRD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRD_CHILDREN),
+static WORD_CRD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("it")],
     values: &[&["credit"]],
     range: 2..=2,
 };
 
-static WORD_CRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRA_CHILDREN),
+static WORD_CRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bine"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -179255,12 +179255,12 @@ pub static WORD_CRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_CP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CP_CHILDREN),
+static WORD_CP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acities"),
         dictgen::InsensitiveStr::Ascii("acity"),
@@ -179290,12 +179290,12 @@ pub static WORD_CP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_CO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CO_CHILDREN),
+static WORD_CO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CO_CHILDREN),
     value: None,
 };
 
-static WORD_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COA_NODE),
     Some(&WORD_COB_NODE),
     Some(&WORD_COC_NODE),
@@ -179324,12 +179324,12 @@ static WORD_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COY_CHILDREN),
+static WORD_COY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COY_CHILDREN),
     value: None,
 };
 
-pub static WORD_COY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("otees"),
         dictgen::InsensitiveStr::Ascii("p"),
@@ -179355,12 +179355,12 @@ pub static WORD_COY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_COV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COV_CHILDREN),
+static WORD_COV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COV_CHILDREN),
     value: None,
 };
 
-pub static WORD_COV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anent"),
         dictgen::InsensitiveStr::Ascii("arage"),
@@ -179448,12 +179448,12 @@ pub static WORD_COV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_COU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COU_CHILDREN),
+static WORD_COU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COU_CHILDREN),
     value: None,
 };
 
-static WORD_COU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_COUC_NODE),
@@ -179482,23 +179482,23 @@ static WORD_COU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUU_CHILDREN),
+static WORD_COUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ld")],
     values: &[&["could"]],
     range: 2..=2,
 };
 
-static WORD_COUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUT_CHILDREN),
+static WORD_COUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -179552,12 +179552,12 @@ pub static WORD_COUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_COUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUS_CHILDREN),
+static WORD_COUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -179581,12 +179581,12 @@ pub static WORD_COUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_COUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUR_CHILDREN),
+static WORD_COUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -179628,23 +179628,23 @@ pub static WORD_COUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_COUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUP_CHILDREN),
+static WORD_COUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("el")],
     values: &[&["couple"]],
     range: 2..=2,
 };
 
-static WORD_COUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COUN_CHILDREN),
+static WORD_COUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COUN_CHILDREN),
     value: None,
 };
 
-static WORD_COUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COUN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_COUNC_NODE),
@@ -179673,12 +179673,12 @@ static WORD_COUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COUNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNT_CHILDREN),
+static WORD_COUNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainer"),
@@ -179808,12 +179808,12 @@ pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_COUNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNS_CHILDREN),
+static WORD_COUNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eil"),
         dictgen::InsensitiveStr::Ascii("elers"),
@@ -179849,12 +179849,12 @@ pub static WORD_COUNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COUNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNR_CHILDREN),
+static WORD_COUNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("ty"),
@@ -179864,12 +179864,12 @@ pub static WORD_COUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_COUNP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNP_CHILDREN),
+static WORD_COUNP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ound"),
         dictgen::InsensitiveStr::Ascii("ounds"),
@@ -179878,34 +179878,34 @@ pub static WORD_COUNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_COUNL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNL_CHILDREN),
+static WORD_COUNL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["could"]],
     range: 1..=1,
 };
 
-static WORD_COUNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNI_CHILDREN),
+static WORD_COUNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["counting"]],
     range: 2..=2,
 };
 
-static WORD_COUND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUND_CHILDREN),
+static WORD_COUND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUND_CHILDREN),
     value: Some(&["could", "count", "found"]),
 };
 
-pub static WORD_COUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -179916,12 +179916,12 @@ pub static WORD_COUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_COUNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNC_CHILDREN),
+static WORD_COUNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -179961,12 +179961,12 @@ pub static WORD_COUNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_COUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUM_CHILDREN),
+static WORD_COUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("munities"),
         dictgen::InsensitiveStr::Ascii("munity"),
@@ -179984,12 +179984,12 @@ pub static WORD_COUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_COUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUL_CHILDREN),
+static WORD_COUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUL_CHILDREN),
     value: Some(&["could"]),
 };
 
-pub static WORD_COUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dnot"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -180021,34 +180021,34 @@ pub static WORD_COUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_COUK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUK_CHILDREN),
+static WORD_COUK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUK_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["could"]],
     range: 1..=1,
 };
 
-static WORD_COUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUG_CHILDREN),
+static WORD_COUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ht")],
     values: &[&["caught", "cough", "fought"]],
     range: 2..=2,
 };
 
-static WORD_COUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUD_CHILDREN),
+static WORD_COUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUD_CHILDREN),
     value: Some(&["could"]),
 };
 
-pub static WORD_COUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lnt"),
@@ -180057,23 +180057,23 @@ pub static WORD_COUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_COUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUC_CHILDREN),
+static WORD_COUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("il")],
     values: &[&["council"]],
     range: 2..=2,
 };
 
-static WORD_COT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COT_CHILDREN),
+static WORD_COT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("ain"),
@@ -180135,12 +180135,12 @@ pub static WORD_COT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_COS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COS_CHILDREN),
+static WORD_COS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -180250,12 +180250,12 @@ pub static WORD_COS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_COR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COR_CHILDREN),
+static WORD_COR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COR_CHILDREN),
     value: None,
 };
 
-static WORD_COR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CORA_NODE),
     None,
     Some(&WORD_CORC_NODE),
@@ -180284,34 +180284,34 @@ static WORD_COR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CORW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORW_CHILDREN),
+static WORD_CORW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORW_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bar")],
     values: &[&["crowbar"]],
     range: 3..=3,
 };
 
-static WORD_CORV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORV_CHILDREN),
+static WORD_CORV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ering")],
     values: &[&["covering"]],
     range: 5..=5,
 };
 
-static WORD_CORU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORU_CHILDREN),
+static WORD_CORU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ching"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -180335,12 +180335,12 @@ pub static WORD_CORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CORS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORS_CHILDREN),
+static WORD_CORS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ari"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -180373,12 +180373,12 @@ pub static WORD_CORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CORR_CHILDREN),
+static WORD_CORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CORR_CHILDREN),
     value: None,
 };
 
-static WORD_CORR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CORR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CORRA_NODE),
     None,
     Some(&WORD_CORRC_NODE),
@@ -180407,12 +180407,12 @@ static WORD_CORR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CORRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRU_CHILDREN),
+static WORD_CORRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lates"),
         dictgen::InsensitiveStr::Ascii("pcion"),
@@ -180438,12 +180438,12 @@ pub static WORD_CORRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CORRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRS_CHILDREN),
+static WORD_CORRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eponding"),
         dictgen::InsensitiveStr::Ascii("pond"),
@@ -180465,12 +180465,12 @@ pub static WORD_CORRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CORRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRR_CHILDREN),
+static WORD_CORRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -180504,12 +180504,12 @@ pub static WORD_CORRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CORRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRP_CHILDREN),
+static WORD_CORRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uted"),
         dictgen::InsensitiveStr::Ascii("ution"),
@@ -180518,12 +180518,12 @@ pub static WORD_CORRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_CORRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRO_CHILDREN),
+static WORD_CORRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lated"),
         dictgen::InsensitiveStr::Ascii("lates"),
@@ -180549,12 +180549,12 @@ pub static WORD_CORRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_CORRL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRL_CHILDREN),
+static WORD_CORRL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eation"),
         dictgen::InsensitiveStr::Ascii("eations"),
@@ -180563,12 +180563,12 @@ pub static WORD_CORRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_CORRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRI_CHILDREN),
+static WORD_CORRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("door"),
         dictgen::InsensitiveStr::Ascii("doors"),
@@ -180604,12 +180604,12 @@ pub static WORD_CORRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_CORRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CORRE_CHILDREN),
+static WORD_CORRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CORRE_CHILDREN),
     value: None,
 };
 
-static WORD_CORRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CORRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CORREA_NODE),
     None,
     Some(&WORD_CORREC_NODE),
@@ -180638,12 +180638,12 @@ static WORD_CORRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CORRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRET_CHILDREN),
+static WORD_CORRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRET_CHILDREN),
     value: Some(&["correct"]),
 };
 
-pub static WORD_CORRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -180653,12 +180653,12 @@ pub static WORD_CORRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_CORRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRES_CHILDREN),
+static WORD_CORRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ond"),
         dictgen::InsensitiveStr::Ascii("onded"),
@@ -180782,12 +180782,12 @@ pub static WORD_CORRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_CORREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREP_CHILDREN),
+static WORD_CORREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ond"),
         dictgen::InsensitiveStr::Ascii("onding"),
@@ -180813,23 +180813,23 @@ pub static WORD_CORREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_CORREO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREO_CHILDREN),
+static WORD_CORREO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("graph")],
     values: &[&["choreograph"]],
     range: 5..=5,
 };
 
-static WORD_CORREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREN_CHILDREN),
+static WORD_CORREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("spond"),
         dictgen::InsensitiveStr::Ascii("sponded"),
@@ -180859,12 +180859,12 @@ pub static WORD_CORREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_CORREL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREL_CHILDREN),
+static WORD_CORREL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("asion"),
@@ -180896,12 +180896,12 @@ pub static WORD_CORREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_CORREK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREK_CHILDREN),
+static WORD_CORREK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ting"),
         dictgen::InsensitiveStr::Ascii("tions"),
@@ -180911,23 +180911,23 @@ pub static WORD_CORREK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_CORREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREG_CHILDREN),
+static WORD_CORREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ated")],
     values: &[&["correlated"]],
     range: 4..=4,
 };
 
-static WORD_CORREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREE_CHILDREN),
+static WORD_CORREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctly"),
@@ -180953,23 +180953,23 @@ pub static WORD_CORREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_CORRED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRED_CHILDREN),
+static WORD_CORRED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ct")],
     values: &[&["correct"]],
     range: 2..=2,
 };
 
-static WORD_CORREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREC_CHILDREN),
+static WORD_CORREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cion"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -181047,23 +181047,23 @@ pub static WORD_CORREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CORREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREA_CHILDREN),
+static WORD_CORREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lation")],
     values: &[&["correlation"]],
     range: 6..=6,
 };
 
-static WORD_CORRD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRD_CHILDREN),
+static WORD_CORRD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inate"),
         dictgen::InsensitiveStr::Ascii("inated"),
@@ -181087,12 +181087,12 @@ pub static WORD_CORRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CORRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRC_CHILDREN),
+static WORD_CORRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -181101,12 +181101,12 @@ pub static WORD_CORRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CORRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRA_CHILDREN),
+static WORD_CORRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lated"),
         dictgen::InsensitiveStr::Ascii("lates"),
@@ -181116,12 +181116,12 @@ pub static WORD_CORRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CORP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORP_CHILDREN),
+static WORD_CORP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("aration"),
@@ -181167,12 +181167,12 @@ pub static WORD_CORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_CORO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORO_CHILDREN),
+static WORD_CORO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llla"),
         dictgen::InsensitiveStr::Ascii("lloa"),
@@ -181208,12 +181208,12 @@ pub static WORD_CORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_CORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORN_CHILDREN),
+static WORD_CORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ders"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -181233,12 +181233,12 @@ pub static WORD_CORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORI_CHILDREN),
+static WORD_CORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dal"),
         dictgen::InsensitiveStr::Ascii("nthains"),
@@ -181268,34 +181268,34 @@ pub static WORD_CORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORG_CHILDREN),
+static WORD_CORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nito")],
     values: &[&["cognito"]],
     range: 4..=4,
 };
 
-static WORD_CORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORF_CHILDREN),
+static WORD_CORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("irms")],
     values: &[&["confirms"]],
     range: 4..=4,
 };
 
-static WORD_CORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORE_CHILDREN),
+static WORD_CORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cct"),
         dictgen::InsensitiveStr::Ascii("cctly"),
@@ -181355,12 +181355,12 @@ pub static WORD_CORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORD_CHILDREN),
+static WORD_CORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iante"),
         dictgen::InsensitiveStr::Ascii("inates"),
@@ -181378,23 +181378,23 @@ pub static WORD_CORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORC_CHILDREN),
+static WORD_CORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("odile")],
     values: &[&["crocodile"]],
     range: 5..=5,
 };
 
-static WORD_CORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORA_CHILDREN),
+static WORD_CORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("lina"),
@@ -181405,12 +181405,12 @@ pub static WORD_CORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_COP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COP_CHILDREN),
+static WORD_COP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COP_CHILDREN),
     value: None,
 };
 
-static WORD_COP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COPA_NODE),
     None,
     None,
@@ -181439,12 +181439,12 @@ static WORD_COP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPY_CHILDREN),
+static WORD_COPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPY_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eight"),
@@ -181506,23 +181506,23 @@ pub static WORD_COPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_COPV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPV_CHILDREN),
+static WORD_COPV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPV_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["cover"]],
     range: 2..=2,
 };
 
-static WORD_COPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPU_CHILDREN),
+static WORD_COPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ling"),
         dictgen::InsensitiveStr::Ascii("right"),
@@ -181546,23 +181546,23 @@ pub static WORD_COPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPS_CHILDREN),
+static WORD_COPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("truction")],
     values: &[&["construction"]],
     range: 8..=8,
 };
 
-static WORD_COPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPR_CHILDREN),
+static WORD_COPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ight"),
         dictgen::InsensitiveStr::Ascii("ighted"),
@@ -181600,12 +181600,12 @@ pub static WORD_COPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_COPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPP_CHILDREN),
+static WORD_COPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ermines"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -181615,12 +181615,12 @@ pub static WORD_COPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_COPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPO_CHILDREN),
+static WORD_COPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nent"),
         dictgen::InsensitiveStr::Ascii("nents"),
@@ -181636,23 +181636,23 @@ pub static WORD_COPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_COPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPN_CHILDREN),
+static WORD_COPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("troller")],
     values: &[&["controller"]],
     range: 7..=7,
 };
 
-static WORD_COPM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPM_CHILDREN),
+static WORD_COPM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etitors"),
         dictgen::InsensitiveStr::Ascii("ilation"),
@@ -181670,12 +181670,12 @@ pub static WORD_COPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_COPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPL_CHILDREN),
+static WORD_COPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ete"),
@@ -181693,12 +181693,12 @@ pub static WORD_COPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_COPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPI_CHILDREN),
+static WORD_COPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -181714,12 +181714,12 @@ pub static WORD_COPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_COPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPE_CHILDREN),
+static WORD_COPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hnagen"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -181759,23 +181759,23 @@ pub static WORD_COPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_COPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPA_CHILDREN),
+static WORD_COPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ny")],
     values: &[&["company"]],
     range: 2..=2,
 };
 
-static WORD_COO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COO_CHILDREN),
+static WORD_COO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COO_CHILDREN),
     value: None,
 };
 
-static WORD_COO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -181804,12 +181804,12 @@ static WORD_COO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOT_CHILDREN),
+static WORD_COOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dinate"),
         dictgen::InsensitiveStr::Ascii("dinated"),
@@ -181827,12 +181827,12 @@ pub static WORD_COOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_COOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COOR_CHILDREN),
+static WORD_COOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COOR_CHILDREN),
     value: None,
 };
 
-static WORD_COOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -181861,12 +181861,12 @@ static WORD_COOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COORP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORP_CHILDREN),
+static WORD_COORP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eration"),
         dictgen::InsensitiveStr::Ascii("erations"),
@@ -181878,23 +181878,23 @@ pub static WORD_COORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_COORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORN_CHILDREN),
+static WORD_COORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ates")],
     values: &[&["coordinates"]],
     range: 4..=4,
 };
 
-static WORD_COORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORI_CHILDREN),
+static WORD_COORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("date"),
         dictgen::InsensitiveStr::Ascii("dated"),
@@ -181928,12 +181928,12 @@ pub static WORD_COORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_COORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORE_CHILDREN),
+static WORD_COORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("spond"),
@@ -181955,12 +181955,12 @@ pub static WORD_COORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORD_CHILDREN),
+static WORD_COORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anate"),
         dictgen::InsensitiveStr::Ascii("anates"),
@@ -182076,12 +182076,12 @@ pub static WORD_COORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_COOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOP_CHILDREN),
+static WORD_COOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aretive"),
         dictgen::InsensitiveStr::Ascii("earte"),
@@ -182107,12 +182107,12 @@ pub static WORD_COOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_COOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOO_CHILDREN),
+static WORD_COOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rdinate"),
         dictgen::InsensitiveStr::Ascii("rdinates"),
@@ -182121,12 +182121,12 @@ pub static WORD_COOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_COON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COON_CHILDREN),
+static WORD_COON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COON_CHILDREN),
     value: None,
 };
 
-pub static WORD_COON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nection"),
         dictgen::InsensitiveStr::Ascii("stantly"),
@@ -182142,12 +182142,12 @@ pub static WORD_COON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_COOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOM_CHILDREN),
+static WORD_COOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("and"),
         dictgen::InsensitiveStr::Ascii("mand"),
@@ -182158,12 +182158,12 @@ pub static WORD_COOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_COOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOL_CHILDREN),
+static WORD_COOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dows"),
         dictgen::InsensitiveStr::Ascii("dwons"),
@@ -182181,34 +182181,34 @@ pub static WORD_COOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_COOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOK_CHILDREN),
+static WORD_COOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oo")],
     values: &[&["cuckoo"]],
     range: 2..=2,
 };
 
-static WORD_COOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOG_CHILDREN),
+static WORD_COOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["cougar"]],
     range: 2..=2,
 };
 
-static WORD_COOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOE_CHILDREN),
+static WORD_COOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fficient"),
         dictgen::InsensitiveStr::Ascii("fficients"),
@@ -182217,12 +182217,12 @@ pub static WORD_COOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_COOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOD_CHILDREN),
+static WORD_COOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inate"),
         dictgen::InsensitiveStr::Ascii("inates"),
@@ -182238,12 +182238,12 @@ pub static WORD_COOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CON_CHILDREN),
+static WORD_CON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CON_CHILDREN),
     value: None,
 };
 
-static WORD_CON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONA_NODE),
     Some(&WORD_CONB_NODE),
     Some(&WORD_CONC_NODE),
@@ -182272,23 +182272,23 @@ static WORD_CON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONY_CHILDREN),
+static WORD_CONY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ak")],
     values: &[&["cognac"]],
     range: 2..=2,
 };
 
-static WORD_CONV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONV_CHILDREN),
+static WORD_CONV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONV_CHILDREN),
     value: None,
 };
 
-static WORD_CONV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONVA_NODE),
     None,
     Some(&WORD_CONVC_NODE),
@@ -182317,12 +182317,12 @@ static WORD_CONV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONVU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVU_CHILDREN),
+static WORD_CONVU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lated"),
         dictgen::InsensitiveStr::Ascii("luted"),
@@ -182331,12 +182331,12 @@ pub static WORD_CONVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_CONVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVS_CHILDREN),
+static WORD_CONVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eration"),
         dictgen::InsensitiveStr::Ascii("erion"),
@@ -182345,12 +182345,12 @@ pub static WORD_CONVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CONVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVR_CHILDREN),
+static WORD_CONVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ets"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -182359,12 +182359,12 @@ pub static WORD_CONVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CONVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVO_CHILDREN),
+static WORD_CONVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("luded"),
         dictgen::InsensitiveStr::Ascii("rsation"),
@@ -182390,23 +182390,23 @@ pub static WORD_CONVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CONVN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVN_CHILDREN),
+static WORD_CONVN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etions")],
     values: &[&["conventions"]],
     range: 6..=6,
 };
 
-static WORD_CONVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVI_CHILDREN),
+static WORD_CONVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -182524,12 +182524,12 @@ pub static WORD_CONVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_CONVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONVE_CHILDREN),
+static WORD_CONVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONVE_CHILDREN),
     value: None,
 };
 
-static WORD_CONVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONVE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -182558,12 +182558,12 @@ static WORD_CONVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONVEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEY_CHILDREN),
+static WORD_CONVEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -182572,23 +182572,23 @@ pub static WORD_CONVEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONVEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEX_CHILDREN),
+static WORD_CONVEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["convex", "convexes"]],
     range: 1..=1,
 };
 
-static WORD_CONVET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVET_CHILDREN),
+static WORD_CONVET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVET_CHILDREN),
     value: Some(&["convert"]),
 };
 
-pub static WORD_CONVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -182610,12 +182610,12 @@ pub static WORD_CONVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONVES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVES_CHILDREN),
+static WORD_CONVES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -182631,12 +182631,12 @@ pub static WORD_CONVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_CONVER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONVER_CHILDREN),
+static WORD_CONVER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONVER_CHILDREN),
     value: Some(&["convert"]),
 };
 
-static WORD_CONVER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONVER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONVERA_NODE),
     None,
     None,
@@ -182665,34 +182665,34 @@ static WORD_CONVER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONVERZ_NODE),
 ];
 
-static WORD_CONVERZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERZ_CHILDREN),
+static WORD_CONVERZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["conservation"]],
     range: 5..=5,
 };
 
-static WORD_CONVERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERY_CHILDREN),
+static WORD_CONVERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERY_CHILDREN),
     value: Some(&["convert"]),
 };
 
-pub static WORD_CONVERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["converting"]],
     range: 3..=3,
 };
 
-static WORD_CONVERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERV_CHILDREN),
+static WORD_CONVERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -182722,12 +182722,12 @@ pub static WORD_CONVERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONVERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERT_CHILDREN),
+static WORD_CONVERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -182773,12 +182773,12 @@ pub static WORD_CONVERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONVERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERS_CHILDREN),
+static WORD_CONVERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERS_CHILDREN),
     value: Some(&["converts", "converse", "convert"]),
 };
 
-pub static WORD_CONVERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("acional"),
@@ -182860,23 +182860,23 @@ pub static WORD_CONVERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_CONVERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERN_CHILDREN),
+static WORD_CONVERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["converting"]],
     range: 3..=3,
 };
 
-static WORD_CONVERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERI_CHILDREN),
+static WORD_CONVERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -182894,12 +182894,12 @@ pub static WORD_CONVERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_CONVERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERG_CHILDREN),
+static WORD_CONVERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -182908,12 +182908,12 @@ pub static WORD_CONVERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_CONVERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERE_CHILDREN),
+static WORD_CONVERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("sly"),
@@ -182923,23 +182923,23 @@ pub static WORD_CONVERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_CONVERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERD_CHILDREN),
+static WORD_CONVERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["conservation"]],
     range: 5..=5,
 };
 
-static WORD_CONVERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERA_CHILDREN),
+static WORD_CONVERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("stion"),
@@ -182955,12 +182955,12 @@ pub static WORD_CONVERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_CONVEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEN_CHILDREN),
+static WORD_CONVEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("cen"),
@@ -183030,23 +183030,23 @@ pub static WORD_CONVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_CONVEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEL_CHILDREN),
+static WORD_CONVEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uted")],
     values: &[&["convoluted"]],
     range: 4..=4,
 };
 
-static WORD_CONVEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEI_CHILDREN),
+static WORD_CONVEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("nce"),
@@ -183070,34 +183070,34 @@ pub static WORD_CONVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_CONVED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVED_CHILDREN),
+static WORD_CONVED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sion")],
     values: &[&["conversion"]],
     range: 4..=4,
 };
 
-static WORD_CONVC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVC_CHILDREN),
+static WORD_CONVC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ition")],
     values: &[&["convictions"]],
     range: 5..=5,
 };
 
-static WORD_CONVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVA_CHILDREN),
+static WORD_CONVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("less"),
         dictgen::InsensitiveStr::Ascii("luted"),
@@ -183117,12 +183117,12 @@ pub static WORD_CONVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CONU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONU_CHILDREN),
+static WORD_CONU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntry"),
         dictgen::InsensitiveStr::Ascii("smer"),
@@ -183131,12 +183131,12 @@ pub static WORD_CONU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_CONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONT_CHILDREN),
+static WORD_CONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONT_CHILDREN),
     value: None,
 };
 
-static WORD_CONT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTA_NODE),
     None,
     Some(&WORD_CONTC_NODE),
@@ -183165,23 +183165,23 @@ static WORD_CONT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTZ_NODE),
 ];
 
-static WORD_CONTZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTZ_CHILDREN),
+static WORD_CONTZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ains")],
     values: &[&["contains"]],
     range: 4..=4,
 };
 
-static WORD_CONTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTU_CHILDREN),
+static WORD_CONTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ining"),
@@ -183197,12 +183197,12 @@ pub static WORD_CONTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CONTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTT_CHILDREN),
+static WORD_CONTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ribute"),
         dictgen::InsensitiveStr::Ascii("ributed"),
@@ -183224,12 +183224,12 @@ pub static WORD_CONTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_CONTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTS_CHILDREN),
+static WORD_CONTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ruction"),
         dictgen::InsensitiveStr::Ascii("ructor"),
@@ -183263,12 +183263,12 @@ pub static WORD_CONTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTR_CHILDREN),
+static WORD_CONTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTR_CHILDREN),
     value: None,
 };
 
-static WORD_CONTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTRA_NODE),
     Some(&WORD_CONTRB_NODE),
     Some(&WORD_CONTRC_NODE),
@@ -183297,23 +183297,23 @@ static WORD_CONTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRY_CHILDREN),
+static WORD_CONTRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRY_CHILDREN),
     value: Some(&["country"]),
 };
 
-pub static WORD_CONTRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ie")],
     values: &[&["countryie"]],
     range: 2..=2,
 };
 
-static WORD_CONTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRU_CHILDREN),
+static WORD_CONTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bite"),
         dictgen::InsensitiveStr::Ascii("bute"),
@@ -183343,23 +183343,23 @@ pub static WORD_CONTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CONTRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRT_CHILDREN),
+static WORD_CONTRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oller")],
     values: &[&["controller"]],
     range: 5..=5,
 };
 
-static WORD_CONTRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRS_CHILDREN),
+static WORD_CONTRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -183375,12 +183375,12 @@ pub static WORD_CONTRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONTRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRR_CHILDREN),
+static WORD_CONTRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ol"),
         dictgen::InsensitiveStr::Ascii("ols"),
@@ -183389,12 +183389,12 @@ pub static WORD_CONTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_CONTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRO_CHILDREN),
+static WORD_CONTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRO_CHILDREN),
     value: Some(&["control"]),
 };
 
-pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ception"),
         dictgen::InsensitiveStr::Ascii("ceptives"),
@@ -183492,23 +183492,23 @@ pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CONTRL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRL_CHILDREN),
+static WORD_CONTRL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRL_CHILDREN),
     value: Some(&["control"]),
 };
 
-pub static WORD_CONTRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ler")],
     values: &[&["controller"]],
     range: 3..=3,
 };
 
-static WORD_CONTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRI_CHILDREN),
+static WORD_CONTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bte"),
         dictgen::InsensitiveStr::Ascii("bted"),
@@ -183620,12 +183620,12 @@ pub static WORD_CONTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CONTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRE_CHILDREN),
+static WORD_CONTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ception"),
         dictgen::InsensitiveStr::Ascii("dict"),
@@ -183645,34 +183645,34 @@ pub static WORD_CONTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CONTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRC_CHILDREN),
+static WORD_CONTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["contract"]],
     range: 1..=1,
 };
 
-static WORD_CONTRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRB_CHILDREN),
+static WORD_CONTRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ution")],
     values: &[&["contribution"]],
     range: 5..=5,
 };
 
-static WORD_CONTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRA_CHILDREN),
+static WORD_CONTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bution"),
         dictgen::InsensitiveStr::Ascii("ccion"),
@@ -183790,12 +183790,12 @@ pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CONTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTO_CHILDREN),
+static WORD_CONTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ler"),
@@ -183829,12 +183829,12 @@ pub static WORD_CONTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CONTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTN_CHILDREN),
+static WORD_CONTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("iue"),
@@ -183852,12 +183852,12 @@ pub static WORD_CONTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CONTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTI_CHILDREN),
+static WORD_CONTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTI_CHILDREN),
     value: None,
 };
 
-static WORD_CONTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTIA_NODE),
     Some(&WORD_CONTIB_NODE),
     None,
@@ -183886,12 +183886,12 @@ static WORD_CONTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIU_CHILDREN),
+static WORD_CONTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -183923,12 +183923,12 @@ pub static WORD_CONTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_CONTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIT_CHILDREN),
+static WORD_CONTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -183938,12 +183938,12 @@ pub static WORD_CONTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_CONTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIR_CHILDREN),
+static WORD_CONTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("buted"),
         dictgen::InsensitiveStr::Ascii("bution"),
@@ -183953,12 +183953,12 @@ pub static WORD_CONTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_CONTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIO_CHILDREN),
+static WORD_CONTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("us"),
         dictgen::InsensitiveStr::Ascii("usly"),
@@ -183967,12 +183967,12 @@ pub static WORD_CONTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTIN_CHILDREN),
+static WORD_CONTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTIN_CHILDREN),
     value: None,
 };
 
-static WORD_CONTIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTINA_NODE),
     None,
     None,
@@ -184001,12 +184001,12 @@ static WORD_CONTIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTINU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINU_CHILDREN),
+static WORD_CONTINU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("aly"),
@@ -184106,34 +184106,34 @@ pub static WORD_CONTINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONTINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINT_CHILDREN),
+static WORD_CONTINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ent")],
     values: &[&["contingent"]],
     range: 3..=3,
 };
 
-static WORD_CONTINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINS_CHILDREN),
+static WORD_CONTINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINS_CHILDREN),
     value: Some(&["contains"]),
 };
 
-pub static WORD_CONTINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_CONTINO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINO_CHILDREN),
+static WORD_CONTINO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ue"),
         dictgen::InsensitiveStr::Ascii("uesly"),
@@ -184153,12 +184153,12 @@ pub static WORD_CONTINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=5,
 };
 
-static WORD_CONTINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINI_CHILDREN),
+static WORD_CONTINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -184176,12 +184176,12 @@ pub static WORD_CONTINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=5,
 };
 
-static WORD_CONTING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTING_CHILDREN),
+static WORD_CONTING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTING_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancy"),
         dictgen::InsensitiveStr::Ascii("ecy"),
@@ -184205,12 +184205,12 @@ pub static WORD_CONTING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_CONTINE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINE_CHILDREN),
+static WORD_CONTINE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINE_CHILDREN),
     value: Some(&["continue", "contain"]),
 };
 
-pub static WORD_CONTINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("nal"),
@@ -184246,12 +184246,12 @@ pub static WORD_CONTINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_CONTINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINA_CHILDREN),
+static WORD_CONTINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -184267,12 +184267,12 @@ pub static WORD_CONTINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_CONTIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIM_CHILDREN),
+static WORD_CONTIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("plate"),
         dictgen::InsensitiveStr::Ascii("plating"),
@@ -184281,12 +184281,12 @@ pub static WORD_CONTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=7,
 };
 
-static WORD_CONTIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIG_CHILDREN),
+static WORD_CONTIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ency"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -184320,23 +184320,23 @@ pub static WORD_CONTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_CONTIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIE_CHILDREN),
+static WORD_CONTIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ntous")],
     values: &[&["contentious"]],
     range: 5..=5,
 };
 
-static WORD_CONTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIB_CHILDREN),
+static WORD_CONTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ute"),
         dictgen::InsensitiveStr::Ascii("uted"),
@@ -184358,12 +184358,12 @@ pub static WORD_CONTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_CONTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIA_CHILDREN),
+static WORD_CONTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ins"),
@@ -184389,23 +184389,23 @@ pub static WORD_CONTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_CONTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTF_CHILDREN),
+static WORD_CONTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ibs")],
     values: &[&["contribs"]],
     range: 3..=3,
 };
 
-static WORD_CONTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTE_CHILDREN),
+static WORD_CONTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTE_CHILDREN),
     value: None,
 };
 
-static WORD_CONTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONTEC_NODE),
@@ -184434,12 +184434,12 @@ static WORD_CONTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEX_CHILDREN),
+static WORD_CONTEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEX_CHILDREN),
     value: Some(&["context"]),
 };
 
-pub static WORD_CONTEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ta"),
         dictgen::InsensitiveStr::Ascii("tes"),
@@ -184463,12 +184463,12 @@ pub static WORD_CONTEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONTET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTET_CHILDREN),
+static WORD_CONTET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTET_CHILDREN),
     value: Some(&["contest", "content", "context"]),
 };
 
-pub static WORD_CONTET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -184478,12 +184478,12 @@ pub static WORD_CONTET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONTES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTES_CHILDREN),
+static WORD_CONTES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("tais"),
@@ -184513,12 +184513,12 @@ pub static WORD_CONTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_CONTER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTER_CHILDREN),
+static WORD_CONTER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTER_CHILDREN),
     value: Some(&["conteur", "counter"]),
 };
 
-pub static WORD_CONTER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mporaneous"),
         dictgen::InsensitiveStr::Ascii("part"),
@@ -184536,12 +184536,12 @@ pub static WORD_CONTER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_CONTEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEN_CHILDREN),
+static WORD_CONTEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEN_CHILDREN),
     value: Some(&["contain"]),
 };
 
-pub static WORD_CONTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ants"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -184619,12 +184619,12 @@ pub static WORD_CONTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CONTEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEM_CHILDREN),
+static WORD_CONTEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("palte"),
         dictgen::InsensitiveStr::Ascii("pate"),
@@ -184656,12 +184656,12 @@ pub static WORD_CONTEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONTEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEI_CHILDREN),
+static WORD_CONTEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -184679,23 +184679,23 @@ pub static WORD_CONTEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONTED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTED_CHILDREN),
+static WORD_CONTED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTED_CHILDREN),
     value: Some(&["counted", "counter", "countered"]),
 };
 
-pub static WORD_CONTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_CONTEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEC_CHILDREN),
+static WORD_CONTEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -184709,12 +184709,12 @@ pub static WORD_CONTEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTC_CHILDREN),
+static WORD_CONTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -184723,12 +184723,12 @@ pub static WORD_CONTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CONTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTA_CHILDREN),
+static WORD_CONTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTA_CHILDREN),
     value: None,
 };
 
-static WORD_CONTA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONTAC_NODE),
@@ -184757,12 +184757,12 @@ static WORD_CONTA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAT_CHILDREN),
+static WORD_CONTAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAT_CHILDREN),
     value: Some(&["contact"]),
 };
 
-pub static WORD_CONTAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("enate"),
@@ -184780,34 +184780,34 @@ pub static WORD_CONTAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_CONTAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAS_CHILDREN),
+static WORD_CONTAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["contacts", "contrast", "contest"]],
     range: 1..=1,
 };
 
-static WORD_CONTAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAR_CHILDREN),
+static WORD_CONTAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["contrary"]],
     range: 1..=1,
 };
 
-static WORD_CONTAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAN_CHILDREN),
+static WORD_CONTAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAN_CHILDREN),
     value: Some(&["contain"]),
 };
 
-pub static WORD_CONTAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cting"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -184851,12 +184851,12 @@ pub static WORD_CONTAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CONTAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAM_CHILDREN),
+static WORD_CONTAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inacion"),
         dictgen::InsensitiveStr::Ascii("inanted"),
@@ -184886,12 +184886,12 @@ pub static WORD_CONTAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_CONTAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAI_CHILDREN),
+static WORD_CONTAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("enr"),
@@ -184993,12 +184993,12 @@ pub static WORD_CONTAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONTAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAG_CHILDREN),
+static WORD_CONTAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("eous"),
@@ -185018,12 +185018,12 @@ pub static WORD_CONTAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_CONTAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAC_CHILDREN),
+static WORD_CONTAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAC_CHILDREN),
     value: Some(&["contact"]),
 };
 
-pub static WORD_CONTAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entaion"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -185043,12 +185043,12 @@ pub static WORD_CONTAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONS_CHILDREN),
+static WORD_CONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONS_CHILDREN),
     value: None,
 };
 
-static WORD_CONS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONSA_NODE),
     None,
     Some(&WORD_CONSC_NODE),
@@ -185077,12 +185077,12 @@ static WORD_CONS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSU_CHILDREN),
+static WORD_CONSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -185172,12 +185172,12 @@ pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CONST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONST_CHILDREN),
+static WORD_CONST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONST_CHILDREN),
     value: None,
 };
 
-static WORD_CONST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONSTA_NODE),
     None,
     Some(&WORD_CONSTC_NODE),
@@ -185206,12 +185206,12 @@ static WORD_CONST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTU_CHILDREN),
+static WORD_CONSTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -185249,12 +185249,12 @@ pub static WORD_CONSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CONSTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTT_CHILDREN),
+static WORD_CONSTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ruct"),
         dictgen::InsensitiveStr::Ascii("ructer"),
@@ -185274,12 +185274,12 @@ pub static WORD_CONSTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_CONSTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONSTR_CHILDREN),
+static WORD_CONSTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONSTR_CHILDREN),
     value: None,
 };
 
-static WORD_CONSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONSTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONSTRA_NODE),
     None,
     Some(&WORD_CONSTRC_NODE),
@@ -185308,12 +185308,12 @@ static WORD_CONSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRU_CHILDREN),
+static WORD_CONSTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ccion"),
@@ -185435,12 +185435,12 @@ pub static WORD_CONSTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONSTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRO_CHILDREN),
+static WORD_CONSTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("llers"),
@@ -185449,12 +185449,12 @@ pub static WORD_CONSTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_CONSTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRI_CHILDREN),
+static WORD_CONSTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -185470,12 +185470,12 @@ pub static WORD_CONSTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_CONSTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRC_CHILDREN),
+static WORD_CONSTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -185511,12 +185511,12 @@ pub static WORD_CONSTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_CONSTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRA_CHILDREN),
+static WORD_CONSTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -185578,45 +185578,45 @@ pub static WORD_CONSTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONSTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTO_CHILDREN),
+static WORD_CONSTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ls")],
     values: &[&["controls"]],
     range: 2..=2,
 };
 
-static WORD_CONSTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTN_CHILDREN),
+static WORD_CONSTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atly")],
     values: &[&["constantly"]],
     range: 4..=4,
 };
 
-static WORD_CONSTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTL_CHILDREN),
+static WORD_CONSTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["costly"]],
     range: 1..=1,
 };
 
-static WORD_CONSTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTI_CHILDREN),
+static WORD_CONSTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llation"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -185702,12 +185702,12 @@ pub static WORD_CONSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_CONSTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTE_CHILDREN),
+static WORD_CONSTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncy"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -185723,23 +185723,23 @@ pub static WORD_CONSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONSTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTC_CHILDREN),
+static WORD_CONSTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("urts")],
     values: &[&["constructs"]],
     range: 4..=4,
 };
 
-static WORD_CONSTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTA_CHILDREN),
+static WORD_CONSTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -185813,12 +185813,12 @@ pub static WORD_CONSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSR_CHILDREN),
+static WORD_CONSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tuct"),
         dictgen::InsensitiveStr::Ascii("tucted"),
@@ -185848,12 +185848,12 @@ pub static WORD_CONSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONSQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSQ_CHILDREN),
+static WORD_CONSQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euences"),
         dictgen::InsensitiveStr::Ascii("uence"),
@@ -185871,12 +185871,12 @@ pub static WORD_CONSQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_CONSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSP_CHILDREN),
+static WORD_CONSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ericies"),
         dictgen::InsensitiveStr::Ascii("irace"),
@@ -185906,12 +185906,12 @@ pub static WORD_CONSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CONSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSO_CHILDREN),
+static WORD_CONSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -185961,12 +185961,12 @@ pub static WORD_CONSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_CONSN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSN_CHILDREN),
+static WORD_CONSN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tant"),
         dictgen::InsensitiveStr::Ascii("tantly"),
@@ -185976,12 +185976,12 @@ pub static WORD_CONSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CONSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSL_CHILDREN),
+static WORD_CONSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("utant"),
         dictgen::InsensitiveStr::Ascii("utants"),
@@ -185991,12 +185991,12 @@ pub static WORD_CONSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CONSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONSI_CHILDREN),
+static WORD_CONSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONSI_CHILDREN),
     value: None,
 };
 
-static WORD_CONSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONSI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONSIC_NODE),
@@ -186025,12 +186025,12 @@ static WORD_CONSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIT_CHILDREN),
+static WORD_CONSIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIT_CHILDREN),
     value: Some(&["consist"]),
 };
 
-pub static WORD_CONSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -186088,12 +186088,12 @@ pub static WORD_CONSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CONSIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIS_CHILDREN),
+static WORD_CONSIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -186151,12 +186151,12 @@ pub static WORD_CONSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIR_CHILDREN),
+static WORD_CONSIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -186165,23 +186165,23 @@ pub static WORD_CONSIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_CONSIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIQ_CHILDREN),
+static WORD_CONSIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uently")],
     values: &[&["consequently"]],
     range: 6..=6,
 };
 
-static WORD_CONSIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIP_CHILDREN),
+static WORD_CONSIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("racies"),
         dictgen::InsensitiveStr::Ascii("racy"),
@@ -186190,23 +186190,23 @@ pub static WORD_CONSIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_CONSIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIO_CHILDREN),
+static WORD_CONSIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("us")],
     values: &[&["conscious"]],
     range: 2..=2,
 };
 
-static WORD_CONSIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIL_CHILDREN),
+static WORD_CONSIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("idate"),
@@ -186216,12 +186216,12 @@ pub static WORD_CONSIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_CONSIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIF_CHILDREN),
+static WORD_CONSIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -186230,12 +186230,12 @@ pub static WORD_CONSIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONSIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIE_CHILDREN),
+static WORD_CONSIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("red"),
@@ -186245,12 +186245,12 @@ pub static WORD_CONSIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONSID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSID_CHILDREN),
+static WORD_CONSID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSID_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("deration"),
@@ -186340,12 +186340,12 @@ pub static WORD_CONSID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIC_CHILDREN),
+static WORD_CONSIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -186363,23 +186363,23 @@ pub static WORD_CONSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSF_CHILDREN),
+static WORD_CONSF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icated")],
     values: &[&["confiscated"]],
     range: 6..=6,
 };
 
-static WORD_CONSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONSE_CHILDREN),
+static WORD_CONSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONSE_CHILDREN),
     value: None,
 };
 
-static WORD_CONSE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONSE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONSEA_NODE),
     None,
     Some(&WORD_CONSEC_NODE),
@@ -186408,45 +186408,45 @@ static WORD_CONSE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEV_CHILDREN),
+static WORD_CONSEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ible")],
     values: &[&["conceivable"]],
     range: 4..=4,
 };
 
-static WORD_CONSEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEU_CHILDREN),
+static WORD_CONSEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tive")],
     values: &[&["consecutive"]],
     range: 4..=4,
 };
 
-static WORD_CONSES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSES_CHILDREN),
+static WORD_CONSES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tently")],
     values: &[&["consistently"]],
     range: 6..=6,
 };
 
-static WORD_CONSER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSER_CHILDREN),
+static WORD_CONSER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSER_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -186502,12 +186502,12 @@ pub static WORD_CONSER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEQ_CHILDREN),
+static WORD_CONSEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eunces"),
         dictgen::InsensitiveStr::Ascii("uece"),
@@ -186551,12 +186551,12 @@ pub static WORD_CONSEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=9,
 };
 
-static WORD_CONSEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEP_CHILDREN),
+static WORD_CONSEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -186565,12 +186565,12 @@ pub static WORD_CONSEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_CONSEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEN_CHILDREN),
+static WORD_CONSEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("quently"),
@@ -186610,34 +186610,34 @@ pub static WORD_CONSEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CONSEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEL_CHILDREN),
+static WORD_CONSEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["consolation"]],
     range: 5..=5,
 };
 
-static WORD_CONSEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEG_CHILDREN),
+static WORD_CONSEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uence")],
     values: &[&["consequence"]],
     range: 5..=5,
 };
 
-static WORD_CONSEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEE_CHILDREN),
+static WORD_CONSEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dd"),
@@ -186648,12 +186648,12 @@ pub static WORD_CONSEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONSEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEC_CHILDREN),
+static WORD_CONSEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tive"),
         dictgen::InsensitiveStr::Ascii("tively"),
@@ -186685,12 +186685,12 @@ pub static WORD_CONSEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_CONSEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEA_CHILDREN),
+static WORD_CONSEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -186699,12 +186699,12 @@ pub static WORD_CONSEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONSD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSD_CHILDREN),
+static WORD_CONSD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ider"),
         dictgen::InsensitiveStr::Ascii("idered"),
@@ -186722,12 +186722,12 @@ pub static WORD_CONSD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSC_CHILDREN),
+static WORD_CONSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("iencious"),
@@ -186769,23 +186769,23 @@ pub static WORD_CONSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CONSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSA_CHILDREN),
+static WORD_CONSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nts")],
     values: &[&["constants"]],
     range: 3..=3,
 };
 
-static WORD_CONR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONR_CHILDREN),
+static WORD_CONR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ete"),
         dictgen::InsensitiveStr::Ascii("ol"),
@@ -186837,12 +186837,12 @@ pub static WORD_CONR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_CONQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONQ_CHILDREN),
+static WORD_CONQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eur"),
         dictgen::InsensitiveStr::Ascii("euring"),
@@ -186872,12 +186872,12 @@ pub static WORD_CONQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONP_CHILDREN),
+static WORD_CONP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ares"),
         dictgen::InsensitiveStr::Ascii("assionate"),
@@ -186929,12 +186929,12 @@ pub static WORD_CONP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_CONO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONO_CHILDREN),
+static WORD_CONO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lization"),
         dictgen::InsensitiveStr::Ascii("ntation"),
@@ -186962,12 +186962,12 @@ pub static WORD_CONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONN_CHILDREN),
+static WORD_CONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONN_CHILDREN),
     value: None,
 };
 
-static WORD_CONN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONNA_NODE),
     None,
     Some(&WORD_CONNC_NODE),
@@ -186996,12 +186996,12 @@ static WORD_CONN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNT_CHILDREN),
+static WORD_CONNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ents"),
         dictgen::InsensitiveStr::Ascii("roller"),
@@ -187010,12 +187010,12 @@ pub static WORD_CONNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CONNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNS_CHILDREN),
+static WORD_CONNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("train"),
         dictgen::InsensitiveStr::Ascii("trained"),
@@ -187025,12 +187025,12 @@ pub static WORD_CONNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CONNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNO_CHILDREN),
+static WORD_CONNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nation"),
         dictgen::InsensitiveStr::Ascii("nations"),
@@ -187048,12 +187048,12 @@ pub static WORD_CONNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_CONNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNN_CHILDREN),
+static WORD_CONNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -187073,23 +187073,23 @@ pub static WORD_CONNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNI_CHILDREN),
+static WORD_CONNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tations")],
     values: &[&["connotations"]],
     range: 7..=7,
 };
 
-static WORD_CONNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNE_CHILDREN),
+static WORD_CONNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cetd"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -187211,12 +187211,12 @@ pub static WORD_CONNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_CONNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNC_CHILDREN),
+static WORD_CONNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ection"),
         dictgen::InsensitiveStr::Ascii("etion"),
@@ -187236,12 +187236,12 @@ pub static WORD_CONNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CONNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNA_CHILDREN),
+static WORD_CONNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("tation"),
@@ -187251,12 +187251,12 @@ pub static WORD_CONNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONM_CHILDREN),
+static WORD_CONM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mutes"),
         dictgen::InsensitiveStr::Ascii("nection"),
@@ -187272,12 +187272,12 @@ pub static WORD_CONM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_CONL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONL_CHILDREN),
+static WORD_CONL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cude"),
         dictgen::InsensitiveStr::Ascii("cuded"),
@@ -187305,12 +187305,12 @@ pub static WORD_CONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_CONJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONJ_CHILDREN),
+static WORD_CONJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecutre"),
         dictgen::InsensitiveStr::Ascii("onction"),
@@ -187340,12 +187340,12 @@ pub static WORD_CONJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_CONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONI_CHILDREN),
+static WORD_CONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cide"),
         dictgen::InsensitiveStr::Ascii("cidence"),
@@ -187417,12 +187417,12 @@ pub static WORD_CONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONG_CHILDREN),
+static WORD_CONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egration"),
         dictgen::InsensitiveStr::Ascii("ergation"),
@@ -187512,12 +187512,12 @@ pub static WORD_CONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_CONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONF_CHILDREN),
+static WORD_CONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONF_CHILDREN),
     value: None,
 };
 
-static WORD_CONF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -187546,12 +187546,12 @@ static WORD_CONF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFU_CHILDREN),
+static WORD_CONFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -187675,12 +187675,12 @@ pub static WORD_CONFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CONFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFR_CHILDREN),
+static WORD_CONFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -187720,12 +187720,12 @@ pub static WORD_CONFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CONFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFO_CHILDREN),
+static WORD_CONFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("guration"),
@@ -187743,12 +187743,12 @@ pub static WORD_CONFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CONFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFL_CHILDREN),
+static WORD_CONFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cit"),
         dictgen::InsensitiveStr::Ascii("citing"),
@@ -187780,12 +187780,12 @@ pub static WORD_CONFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CONFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONFI_CHILDREN),
+static WORD_CONFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONFI_CHILDREN),
     value: None,
 };
 
-static WORD_CONFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONFI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONFIC_NODE),
@@ -187814,12 +187814,12 @@ static WORD_CONFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONFIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIU_CHILDREN),
+static WORD_CONFIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("grable"),
@@ -187849,23 +187849,23 @@ pub static WORD_CONFIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONFIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIT_CHILDREN),
+static WORD_CONFIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uration")],
     values: &[&["configuration"]],
     range: 7..=7,
 };
 
-static WORD_CONFIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIS_CHILDREN),
+static WORD_CONFIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("gated"),
@@ -187874,12 +187874,12 @@ pub static WORD_CONFIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_CONFIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIR_CHILDREN),
+static WORD_CONFIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIR_CHILDREN),
     value: Some(&["confirm"]),
 };
 
-pub static WORD_CONFIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amtion"),
         dictgen::InsensitiveStr::Ascii("macion"),
@@ -187911,12 +187911,12 @@ pub static WORD_CONFIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CONFIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIN_CHILDREN),
+static WORD_CONFIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gs"),
@@ -187934,12 +187934,12 @@ pub static WORD_CONFIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONFIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIM_CHILDREN),
+static WORD_CONFIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIM_CHILDREN),
     value: Some(&["confirm"]),
 };
 
-pub static WORD_CONFIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -187963,12 +187963,12 @@ pub static WORD_CONFIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_CONFIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIL_CHILDREN),
+static WORD_CONFIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cting"),
@@ -187978,12 +187978,12 @@ pub static WORD_CONFIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_CONFIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONFIG_CHILDREN),
+static WORD_CONFIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONFIG_CHILDREN),
     value: None,
 };
 
-static WORD_CONFIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONFIG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONFIGA_NODE),
     None,
     None,
@@ -188012,12 +188012,12 @@ static WORD_CONFIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONFIGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGU_CHILDREN),
+static WORD_CONFIGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("arble"),
@@ -188137,12 +188137,12 @@ pub static WORD_CONFIGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_CONFIGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGR_CHILDREN),
+static WORD_CONFIGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -188166,23 +188166,23 @@ pub static WORD_CONFIGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_CONFIGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGL_CHILDREN),
+static WORD_CONFIGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGL_CHILDREN),
     value: Some(&["config"]),
 };
 
-pub static WORD_CONFIGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_CONFIGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGI_CHILDREN),
+static WORD_CONFIGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("guration"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -188198,12 +188198,12 @@ pub static WORD_CONFIGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_CONFIGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGE_CHILDREN),
+static WORD_CONFIGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -188212,23 +188212,23 @@ pub static WORD_CONFIGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=1,
 };
 
-static WORD_CONFIGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGA_CHILDREN),
+static WORD_CONFIGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ration")],
     values: &[&["configuration"]],
     range: 6..=6,
 };
 
-static WORD_CONFIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIF_CHILDREN),
+static WORD_CONFIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("urable"),
         dictgen::InsensitiveStr::Ascii("uration"),
@@ -188244,12 +188244,12 @@ pub static WORD_CONFIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_CONFID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFID_CHILDREN),
+static WORD_CONFID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFID_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("antal"),
@@ -188299,12 +188299,12 @@ pub static WORD_CONFID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_CONFIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIC_CHILDREN),
+static WORD_CONFIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -188320,12 +188320,12 @@ pub static WORD_CONFIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONFG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFG_CHILDREN),
+static WORD_CONFG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("iuration"),
@@ -188347,12 +188347,12 @@ pub static WORD_CONFG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CONFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFF_CHILDREN),
+static WORD_CONFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ig"),
         dictgen::InsensitiveStr::Ascii("iguration"),
@@ -188361,12 +188361,12 @@ pub static WORD_CONFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CONFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFE_CHILDREN),
+static WORD_CONFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daracy"),
         dictgen::InsensitiveStr::Ascii("darate"),
@@ -188436,12 +188436,12 @@ pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_CONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONE_CHILDREN),
+static WORD_CONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONE_CHILDREN),
     value: None,
 };
 
-static WORD_CONE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONEC_NODE),
@@ -188470,12 +188470,12 @@ static WORD_CONE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONEX_CHILDREN),
+static WORD_CONEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -188489,12 +188489,12 @@ pub static WORD_CONEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CONET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONET_CHILDREN),
+static WORD_CONET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONET_CHILDREN),
     value: Some(&["connect"]),
 };
 
-pub static WORD_CONET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -188526,12 +188526,12 @@ pub static WORD_CONET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_CONES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONES_CHILDREN),
+static WORD_CONES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cutive"),
         dictgen::InsensitiveStr::Ascii("encus"),
@@ -188540,12 +188540,12 @@ pub static WORD_CONES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CONER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONER_CHILDREN),
+static WORD_CONER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONER_CHILDREN),
     value: Some(&["corner", "coroner"]),
 };
 
-pub static WORD_CONER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gence"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -188577,12 +188577,12 @@ pub static WORD_CONER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CONEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONEN_CHILDREN),
+static WORD_CONEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -188624,12 +188624,12 @@ pub static WORD_CONEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CONEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONEE_CHILDREN),
+static WORD_CONEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -188657,12 +188657,12 @@ pub static WORD_CONEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CONEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONEC_CHILDREN),
+static WORD_CONEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -188740,12 +188740,12 @@ pub static WORD_CONEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COND_CHILDREN),
+static WORD_COND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COND_CHILDREN),
     value: None,
 };
 
-static WORD_COND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COND_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONDA_NODE),
     None,
     None,
@@ -188774,12 +188774,12 @@ static WORD_COND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDU_CHILDREN),
+static WORD_CONDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctiong"),
         dictgen::InsensitiveStr::Ascii("ctuve"),
@@ -188799,12 +188799,12 @@ pub static WORD_CONDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CONDT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDT_CHILDREN),
+static WORD_CONDT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iion"),
         dictgen::InsensitiveStr::Ascii("iions"),
@@ -188836,12 +188836,12 @@ pub static WORD_CONDT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CONDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDR_CHILDREN),
+static WORD_CONDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adicted"),
         dictgen::InsensitiveStr::Ascii("adicting"),
@@ -188859,12 +188859,12 @@ pub static WORD_CONDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_CONDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDO_CHILDREN),
+static WORD_CONDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lances"),
         dictgen::InsensitiveStr::Ascii("lencies"),
@@ -188888,23 +188888,23 @@ pub static WORD_CONDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONDN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDN_CHILDREN),
+static WORD_CONDN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tional")],
     values: &[&["conditional"]],
     range: 6..=6,
 };
 
-static WORD_CONDM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDM_CHILDREN),
+static WORD_CONDM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("enation"),
@@ -188920,12 +188920,12 @@ pub static WORD_CONDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CONDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDI_CHILDREN),
+static WORD_CONDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cional"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -189027,12 +189027,12 @@ pub static WORD_CONDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CONDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDF_CHILDREN),
+static WORD_CONDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iguration"),
         dictgen::InsensitiveStr::Ascii("igurations"),
@@ -189052,12 +189052,12 @@ pub static WORD_CONDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_CONDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDE_CHILDREN),
+static WORD_CONDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("feracy"),
         dictgen::InsensitiveStr::Ascii("m"),
@@ -189109,12 +189109,12 @@ pub static WORD_CONDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CONDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDA_CHILDREN),
+static WORD_CONDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mnation"),
         dictgen::InsensitiveStr::Ascii("mned"),
@@ -189130,12 +189130,12 @@ pub static WORD_CONDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONC_CHILDREN),
+static WORD_CONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONC_CHILDREN),
     value: None,
 };
 
-static WORD_CONC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONCA_NODE),
     None,
     None,
@@ -189164,12 +189164,12 @@ static WORD_CONC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCU_CHILDREN),
+static WORD_CONCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lsion"),
         dictgen::InsensitiveStr::Ascii("lsions"),
@@ -189219,23 +189219,23 @@ pub static WORD_CONCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCT_CHILDREN),
+static WORD_CONCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ats")],
     values: &[&["contacts"]],
     range: 3..=3,
 };
 
-static WORD_CONCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCS_CHILDREN),
+static WORD_CONCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ience"),
         dictgen::InsensitiveStr::Ascii("ious"),
@@ -189251,12 +189251,12 @@ pub static WORD_CONCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCR_CHILDREN),
+static WORD_CONCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eet"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -189266,12 +189266,12 @@ pub static WORD_CONCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CONCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCO_CHILDREN),
+static WORD_CONCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("rrent"),
@@ -189280,23 +189280,23 @@ pub static WORD_CONCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CONCN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCN_CHILDREN),
+static WORD_CONCN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etration")],
     values: &[&["concentrations"]],
     range: 8..=8,
 };
 
-static WORD_CONCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCL_CHILDREN),
+static WORD_CONCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eanment"),
         dictgen::InsensitiveStr::Ascii("suion"),
@@ -189336,12 +189336,12 @@ pub static WORD_CONCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CONCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCI_CHILDREN),
+static WORD_CONCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bes"),
         dictgen::InsensitiveStr::Ascii("cely"),
@@ -189393,12 +189393,12 @@ pub static WORD_CONCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CONCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCH_CHILDREN),
+static WORD_CONCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ances"),
@@ -189416,12 +189416,12 @@ pub static WORD_CONCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CONCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONCE_CHILDREN),
+static WORD_CONCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONCE_CHILDREN),
     value: None,
 };
 
-static WORD_CONCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONCE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONCEA_NODE),
     None,
     Some(&WORD_CONCEC_NODE),
@@ -189450,12 +189450,12 @@ static WORD_CONCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONCEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEV_CHILDREN),
+static WORD_CONCEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -189471,23 +189471,23 @@ pub static WORD_CONCEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_CONCET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCET_CHILDREN),
+static WORD_CONCET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCET_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["concede"]],
     range: 2..=2,
 };
 
-static WORD_CONCES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCES_CHILDREN),
+static WORD_CONCES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ions"),
         dictgen::InsensitiveStr::Ascii("so"),
@@ -189496,12 +189496,12 @@ pub static WORD_CONCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONCER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCER_CHILDREN),
+static WORD_CONCER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCER_CHILDREN),
     value: Some(&["concern"]),
 };
 
-pub static WORD_CONCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("end"),
@@ -189543,12 +189543,12 @@ pub static WORD_CONCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONCEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEQ_CHILDREN),
+static WORD_CONCEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uence"),
         dictgen::InsensitiveStr::Ascii("uences"),
@@ -189564,12 +189564,12 @@ pub static WORD_CONCEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_CONCEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEP_CHILDREN),
+static WORD_CONCEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("ta"),
@@ -189593,12 +189593,12 @@ pub static WORD_CONCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_CONCEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEO_CHILDREN),
+static WORD_CONCEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("us"),
         dictgen::InsensitiveStr::Ascii("usally"),
@@ -189608,12 +189608,12 @@ pub static WORD_CONCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CONCEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEN_CHILDREN),
+static WORD_CONCEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crate"),
         dictgen::InsensitiveStr::Ascii("cration"),
@@ -189685,12 +189685,12 @@ pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CONCEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEL_CHILDREN),
+static WORD_CONCEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aed"),
         dictgen::InsensitiveStr::Ascii("aer"),
@@ -189708,12 +189708,12 @@ pub static WORD_CONCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CONCEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEI_CHILDREN),
+static WORD_CONCEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("tual"),
@@ -189731,12 +189731,12 @@ pub static WORD_CONCEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CONCEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEE_CHILDREN),
+static WORD_CONCEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dd"),
@@ -189747,12 +189747,12 @@ pub static WORD_CONCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONCED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCED_CHILDREN),
+static WORD_CONCED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("endo"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -189761,34 +189761,34 @@ pub static WORD_CONCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=4,
 };
 
-static WORD_CONCEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEC_CHILDREN),
+static WORD_CONCEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utive")],
     values: &[&["consecutive"]],
     range: 5..=5,
 };
 
-static WORD_CONCEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEA_CHILDREN),
+static WORD_CONCEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ld")],
     values: &[&["concealed"]],
     range: 2..=2,
 };
 
-static WORD_CONCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCA_CHILDREN),
+static WORD_CONCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nented"),
         dictgen::InsensitiveStr::Ascii("neted"),
@@ -189852,12 +189852,12 @@ pub static WORD_CONCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_CONB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONB_CHILDREN),
+static WORD_CONB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ination"),
         dictgen::InsensitiveStr::Ascii("inations"),
@@ -189875,12 +189875,12 @@ pub static WORD_CONB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CONA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONA_CHILDREN),
+static WORD_CONA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -189934,12 +189934,12 @@ pub static WORD_CONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COM_CHILDREN),
+static WORD_COM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COM_CHILDREN),
     value: None,
 };
 
-static WORD_COM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMA_NODE),
     Some(&WORD_COMB_NODE),
     Some(&WORD_COMC_NODE),
@@ -189968,12 +189968,12 @@ static WORD_COM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMV_CHILDREN),
+static WORD_COMV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMV_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entions"),
         dictgen::InsensitiveStr::Ascii("ersion"),
@@ -189983,12 +189983,12 @@ pub static WORD_COMV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_COMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMU_CHILDREN),
+static WORD_COMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nicate"),
         dictgen::InsensitiveStr::Ascii("nicating"),
@@ -190024,12 +190024,12 @@ pub static WORD_COMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_COMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMT_CHILDREN),
+static WORD_COMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ained"),
@@ -190057,12 +190057,12 @@ pub static WORD_COMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_COMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMS_CHILDREN),
+static WORD_COMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etic"),
         dictgen::InsensitiveStr::Ascii("etics"),
@@ -190096,12 +190096,12 @@ pub static WORD_COMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_COMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMR_CHILDREN),
+static WORD_COMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adets"),
         dictgen::InsensitiveStr::Ascii("adre"),
@@ -190139,12 +190139,12 @@ pub static WORD_COMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_COMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMP_CHILDREN),
+static WORD_COMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMP_CHILDREN),
     value: None,
 };
 
-static WORD_COMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMPA_NODE),
     None,
     None,
@@ -190173,12 +190173,12 @@ static WORD_COMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPU_CHILDREN),
+static WORD_COMPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atation"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -190258,12 +190258,12 @@ pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_COMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPT_CHILDREN),
+static WORD_COMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abile"),
         dictgen::InsensitiveStr::Ascii("ability"),
@@ -190293,12 +190293,12 @@ pub static WORD_COMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COMPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPS_CHILDREN),
+static WORD_COMPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -190308,12 +190308,12 @@ pub static WORD_COMPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_COMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPR_CHILDREN),
+static WORD_COMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("aison"),
@@ -190439,12 +190439,12 @@ pub static WORD_COMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_COMPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPP_CHILDREN),
+static WORD_COMPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atible"),
         dictgen::InsensitiveStr::Ascii("iler"),
@@ -190460,12 +190460,12 @@ pub static WORD_COMPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_COMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPO_CHILDREN),
+static WORD_COMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPO_CHILDREN),
     value: None,
 };
 
-static WORD_COMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -190494,23 +190494,23 @@ static WORD_COMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOU_CHILDREN),
+static WORD_COMPOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nt")],
     values: &[&["compound"]],
     range: 2..=2,
 };
 
-static WORD_COMPOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOT_CHILDREN),
+static WORD_COMPOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -190519,12 +190519,12 @@ pub static WORD_COMPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_COMPOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOS_CHILDREN),
+static WORD_COMPOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ablity"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -190586,12 +190586,12 @@ pub static WORD_COMPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_COMPOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOR_CHILDREN),
+static WORD_COMPOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ession"),
@@ -190600,12 +190600,12 @@ pub static WORD_COMPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_COMPOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOO_CHILDREN),
+static WORD_COMPOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nent"),
         dictgen::InsensitiveStr::Ascii("nents"),
@@ -190614,12 +190614,12 @@ pub static WORD_COMPOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_COMPON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPON_CHILDREN),
+static WORD_COMPON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPON_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -190685,12 +190685,12 @@ pub static WORD_COMPON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_COMPOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOM_CHILDREN),
+static WORD_COMPOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -190699,12 +190699,12 @@ pub static WORD_COMPOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_COMPOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOL_CHILDREN),
+static WORD_COMPOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("sive"),
@@ -190720,12 +190720,12 @@ pub static WORD_COMPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_COMPOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOE_CHILDREN),
+static WORD_COMPOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nents"),
         dictgen::InsensitiveStr::Ascii("nnt"),
@@ -190743,12 +190743,12 @@ pub static WORD_COMPOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_COMPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPN_CHILDREN),
+static WORD_COMPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aies"),
         dictgen::InsensitiveStr::Ascii("ay"),
@@ -190766,12 +190766,12 @@ pub static WORD_COMPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_COMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPL_CHILDREN),
+static WORD_COMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPL_CHILDREN),
     value: None,
 };
 
-static WORD_COMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMPLA_NODE),
     None,
     Some(&WORD_COMPLC_NODE),
@@ -190800,23 +190800,23 @@ static WORD_COMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLY_CHILDREN),
+static WORD_COMPLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["complies"]],
     range: 1..=1,
 };
 
-static WORD_COMPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLU_CHILDREN),
+static WORD_COMPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sion"),
         dictgen::InsensitiveStr::Ascii("sions"),
@@ -190834,12 +190834,12 @@ pub static WORD_COMPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_COMPLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLT_CHILDREN),
+static WORD_COMPLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -190848,23 +190848,23 @@ pub static WORD_COMPLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_COMPLM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLM_CHILDREN),
+static WORD_COMPLM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enet")],
     values: &[&["complement"]],
     range: 4..=4,
 };
 
-static WORD_COMPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLI_CHILDREN),
+static WORD_COMPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -190988,12 +190988,12 @@ pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_COMPLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLE_CHILDREN),
+static WORD_COMPLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLE_CHILDREN),
     value: Some(&["complete"]),
 };
 
-pub static WORD_COMPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -191127,12 +191127,12 @@ pub static WORD_COMPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_COMPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLC_CHILDREN),
+static WORD_COMPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -191142,12 +191142,12 @@ pub static WORD_COMPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_COMPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLA_CHILDREN),
+static WORD_COMPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cant"),
         dictgen::InsensitiveStr::Ascii("cient"),
@@ -191195,12 +191195,12 @@ pub static WORD_COMPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_COMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPI_CHILDREN),
+static WORD_COMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -191322,34 +191322,34 @@ pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COMPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPH_CHILDREN),
+static WORD_COMPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rehensive")],
     values: &[&["comprehensive"]],
     range: 9..=9,
 };
 
-static WORD_COMPF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPF_CHILDREN),
+static WORD_COMPF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPF_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ortable")],
     values: &[&["comfortable"]],
     range: 7..=7,
 };
 
-static WORD_COMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPE_CHILDREN),
+static WORD_COMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPE_CHILDREN),
     value: None,
 };
 
-static WORD_COMPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMPEA_NODE),
     None,
     None,
@@ -191378,23 +191378,23 @@ static WORD_COMPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEX_CHILDREN),
+static WORD_COMPEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEX_CHILDREN),
     value: Some(&["complex"]),
 };
 
-pub static WORD_COMPEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_COMPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPET_CHILDREN),
+static WORD_COMPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ant"),
@@ -191492,12 +191492,12 @@ pub static WORD_COMPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_COMPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPES_CHILDREN),
+static WORD_COMPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("itions"),
@@ -191507,12 +191507,12 @@ pub static WORD_COMPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_COMPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPER_CHILDREN),
+static WORD_COMPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -191530,12 +191530,12 @@ pub static WORD_COMPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_COMPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEN_CHILDREN),
+static WORD_COMPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("duim"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -191577,23 +191577,23 @@ pub static WORD_COMPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_COMPEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEM_CHILDREN),
+static WORD_COMPEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dium")],
     values: &[&["compendium"]],
     range: 4..=4,
 };
 
-static WORD_COMPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEL_CHILDREN),
+static WORD_COMPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ete"),
@@ -191633,12 +191633,12 @@ pub static WORD_COMPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_COMPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEI_CHILDREN),
+static WORD_COMPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tions"),
@@ -191648,23 +191648,23 @@ pub static WORD_COMPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_COMPEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEE_CHILDREN),
+static WORD_COMPEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ting")],
     values: &[&["completing"]],
     range: 4..=4,
 };
 
-static WORD_COMPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPED_CHILDREN),
+static WORD_COMPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("itive"),
@@ -191684,12 +191684,12 @@ pub static WORD_COMPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_COMPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEA_CHILDREN),
+static WORD_COMPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("re"),
         dictgen::InsensitiveStr::Ascii("red"),
@@ -191715,12 +191715,12 @@ pub static WORD_COMPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_COMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPA_CHILDREN),
+static WORD_COMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPA_CHILDREN),
     value: None,
 };
 
-static WORD_COMPA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_COMPAB_NODE),
     Some(&WORD_COMPAC_NODE),
@@ -191749,23 +191749,23 @@ static WORD_COMPA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAY_CHILDREN),
+static WORD_COMPAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAY_CHILDREN),
     value: Some(&["company"]),
 };
 
-pub static WORD_COMPAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tibility")],
     values: &[&["compatibility"]],
     range: 8..=8,
 };
 
-static WORD_COMPAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAT_CHILDREN),
+static WORD_COMPAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abable"),
         dictgen::InsensitiveStr::Ascii("abiity"),
@@ -191873,12 +191873,12 @@ pub static WORD_COMPAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_COMPAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAS_CHILDREN),
+static WORD_COMPAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("sione"),
@@ -191894,12 +191894,12 @@ pub static WORD_COMPAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_COMPAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPAR_CHILDREN),
+static WORD_COMPAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPAR_CHILDREN),
     value: None,
 };
 
-static WORD_COMPAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMPARA_NODE),
     None,
     None,
@@ -191928,12 +191928,12 @@ static WORD_COMPAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPART_CHILDREN),
+static WORD_COMPART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPART_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -191943,12 +191943,12 @@ pub static WORD_COMPART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_COMPARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARS_CHILDREN),
+static WORD_COMPARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -191958,23 +191958,23 @@ pub static WORD_COMPARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=4,
 };
 
-static WORD_COMPARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARR_CHILDREN),
+static WORD_COMPARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["compare"]],
     range: 1..=1,
 };
 
-static WORD_COMPARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARO_CHILDREN),
+static WORD_COMPARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tor"),
         dictgen::InsensitiveStr::Ascii("tors"),
@@ -191983,23 +191983,23 @@ pub static WORD_COMPARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_COMPARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARM_CHILDREN),
+static WORD_COMPARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ent")],
     values: &[&["compartment"]],
     range: 3..=3,
 };
 
-static WORD_COMPARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARI_CHILDREN),
+static WORD_COMPARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -192111,12 +192111,12 @@ pub static WORD_COMPARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_COMPARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARE_CHILDREN),
+static WORD_COMPARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -192144,12 +192144,12 @@ pub static WORD_COMPARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=6,
 };
 
-static WORD_COMPARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARA_CHILDREN),
+static WORD_COMPARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bil"),
         dictgen::InsensitiveStr::Ascii("bile"),
@@ -192187,12 +192187,12 @@ pub static WORD_COMPARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_COMPAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAN_CHILDREN),
+static WORD_COMPAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dium"),
         dictgen::InsensitiveStr::Ascii("ians"),
@@ -192224,12 +192224,12 @@ pub static WORD_COMPAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_COMPAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAL_CHILDREN),
+static WORD_COMPAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -192245,12 +192245,12 @@ pub static WORD_COMPAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_COMPAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAI_CHILDREN),
+static WORD_COMPAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -192288,12 +192288,12 @@ pub static WORD_COMPAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_COMPAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAG_CHILDREN),
+static WORD_COMPAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nion"),
         dictgen::InsensitiveStr::Ascii("nons"),
@@ -192303,12 +192303,12 @@ pub static WORD_COMPAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_COMPAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAD_CHILDREN),
+static WORD_COMPAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibility"),
         dictgen::InsensitiveStr::Ascii("ible"),
@@ -192317,23 +192317,23 @@ pub static WORD_COMPAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_COMPAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAC_CHILDREN),
+static WORD_COMPAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tible")],
     values: &[&["compactable"]],
     range: 5..=5,
 };
 
-static WORD_COMPAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAB_CHILDREN),
+static WORD_COMPAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibility"),
         dictgen::InsensitiveStr::Ascii("ility"),
@@ -192353,12 +192353,12 @@ pub static WORD_COMPAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_COMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMO_CHILDREN),
+static WORD_COMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dore"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -192384,12 +192384,12 @@ pub static WORD_COMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_COMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMN_CHILDREN),
+static WORD_COMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mand"),
         dictgen::InsensitiveStr::Ascii("nected"),
@@ -192409,12 +192409,12 @@ pub static WORD_COMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_COMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMM_CHILDREN),
+static WORD_COMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMM_CHILDREN),
     value: None,
 };
 
-static WORD_COMM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMMA_NODE),
     None,
     None,
@@ -192443,12 +192443,12 @@ static WORD_COMM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMU_CHILDREN),
+static WORD_COMMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ication"),
@@ -192580,12 +192580,12 @@ pub static WORD_COMMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_COMMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMT_CHILDREN),
+static WORD_COMMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMT_CHILDREN),
     value: Some(&["commit"]),
 };
 
-pub static WORD_COMMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("iment"),
@@ -192603,12 +192603,12 @@ pub static WORD_COMMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_COMMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMP_CHILDREN),
+static WORD_COMMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("action"),
@@ -192690,12 +192690,12 @@ pub static WORD_COMMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COMMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMO_CHILDREN),
+static WORD_COMMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dites"),
         dictgen::InsensitiveStr::Ascii("ditites"),
@@ -192737,12 +192737,12 @@ pub static WORD_COMMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_COMMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMN_CHILDREN),
+static WORD_COMMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ad"),
@@ -192808,12 +192808,12 @@ pub static WORD_COMMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COMMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMM_CHILDREN),
+static WORD_COMMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("and"),
@@ -192877,12 +192877,12 @@ pub static WORD_COMMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COMMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMI_CHILDREN),
+static WORD_COMMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -192992,12 +192992,12 @@ pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_COMME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMME_CHILDREN),
+static WORD_COMME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMME_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cen"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -193117,12 +193117,12 @@ pub static WORD_COMME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COMMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMA_CHILDREN),
+static WORD_COMMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dline"),
@@ -193196,12 +193196,12 @@ pub static WORD_COMMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_COML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COML_CHILDREN),
+static WORD_COML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COML_CHILDREN),
     value: None,
 };
 
-pub static WORD_COML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ained"),
@@ -193241,12 +193241,12 @@ pub static WORD_COML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_COMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMI_CHILDREN),
+static WORD_COMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -193320,12 +193320,12 @@ pub static WORD_COMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_COMF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMF_CHILDREN),
+static WORD_COMF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMF_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ertable"),
         dictgen::InsensitiveStr::Ascii("ertably"),
@@ -193385,12 +193385,12 @@ pub static WORD_COMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_COME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COME_CHILDREN),
+static WORD_COME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COME_CHILDREN),
     value: None,
 };
 
-pub static WORD_COME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -193460,12 +193460,12 @@ pub static WORD_COME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_COMD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMD_CHILDREN),
+static WORD_COMD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eic"),
         dictgen::InsensitiveStr::Ascii("emnation"),
@@ -193474,23 +193474,23 @@ pub static WORD_COMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_COMC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMC_CHILDREN),
+static WORD_COMC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eptually")],
     values: &[&["conceptually"]],
     range: 8..=8,
 };
 
-static WORD_COMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMB_CHILDREN),
+static WORD_COMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("ack"),
@@ -193590,12 +193590,12 @@ pub static WORD_COMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_COMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMA_CHILDREN),
+static WORD_COMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dres"),
         dictgen::InsensitiveStr::Ascii("mmand"),
@@ -193693,12 +193693,12 @@ pub static WORD_COMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_COL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COL_CHILDREN),
+static WORD_COL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COL_CHILDREN),
     value: None,
 };
 
-static WORD_COL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COLA_NODE),
     None,
     None,
@@ -193727,12 +193727,12 @@ static WORD_COL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLU_CHILDREN),
+static WORD_COLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bmia"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -193782,23 +193782,23 @@ pub static WORD_COLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_COLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLS_CHILDREN),
+static WORD_COLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["closed"]],
     range: 2..=2,
 };
 
-static WORD_COLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLO_CHILDREN),
+static WORD_COLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ardo"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -193890,12 +193890,12 @@ pub static WORD_COLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COLM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLM_CHILDREN),
+static WORD_COLM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -193905,12 +193905,12 @@ pub static WORD_COLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_COLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COLL_CHILDREN),
+static WORD_COLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COLL_CHILDREN),
     value: None,
 };
 
-static WORD_COLL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COLL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COLLA_NODE),
     Some(&WORD_COLLB_NODE),
     Some(&WORD_COLLC_NODE),
@@ -193939,12 +193939,12 @@ static WORD_COLL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COLLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLU_CHILDREN),
+static WORD_COLLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mn"),
         dictgen::InsensitiveStr::Ascii("mns"),
@@ -193953,12 +193953,12 @@ pub static WORD_COLLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_COLLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLS_CHILDREN),
+static WORD_COLLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -193967,12 +193967,12 @@ pub static WORD_COLLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_COLLP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLP_CHILDREN),
+static WORD_COLLP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -193988,12 +193988,12 @@ pub static WORD_COLLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_COLLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLO_CHILDREN),
+static WORD_COLLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("barate"),
         dictgen::InsensitiveStr::Ascii("baration"),
@@ -194031,12 +194031,12 @@ pub static WORD_COLLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COLLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLL_CHILDREN),
+static WORD_COLLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apses"),
         dictgen::InsensitiveStr::Ascii("ect"),
@@ -194046,12 +194046,12 @@ pub static WORD_COLLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_COLLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLI_CHILDREN),
+static WORD_COLLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dies"),
         dictgen::InsensitiveStr::Ascii("quial"),
@@ -194085,23 +194085,23 @@ pub static WORD_COLLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_COLLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLG_CHILDREN),
+static WORD_COLLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["college"]],
     range: 1..=1,
 };
 
-static WORD_COLLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLE_CHILDREN),
+static WORD_COLLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -194203,34 +194203,34 @@ pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COLLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLC_CHILDREN),
+static WORD_COLLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etion")],
     values: &[&["collections"]],
     range: 5..=5,
 };
 
-static WORD_COLLB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLB_CHILDREN),
+static WORD_COLLB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLB_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orative")],
     values: &[&["collaborative"]],
     range: 7..=7,
 };
 
-static WORD_COLLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLA_CHILDREN),
+static WORD_COLLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("barate"),
         dictgen::InsensitiveStr::Ascii("baration"),
@@ -194330,12 +194330,12 @@ pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_COLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLI_CHILDREN),
+static WORD_COLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -194345,23 +194345,23 @@ pub static WORD_COLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_COLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLG_CHILDREN),
+static WORD_COLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("one")],
     values: &[&["cologne"]],
     range: 3..=3,
 };
 
-static WORD_COLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLE_CHILDREN),
+static WORD_COLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agues"),
         dictgen::InsensitiveStr::Ascii("asing"),
@@ -194411,23 +194411,23 @@ pub static WORD_COLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COLD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLD_CHILDREN),
+static WORD_COLD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("plg")],
     values: &[&["coldplug"]],
     range: 3..=3,
 };
 
-static WORD_COLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLA_CHILDREN),
+static WORD_COLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("borate"),
         dictgen::InsensitiveStr::Ascii("boration"),
@@ -194449,23 +194449,23 @@ pub static WORD_COLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_COK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COK_CHILDREN),
+static WORD_COK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COK_CHILDREN),
     value: None,
 };
 
-pub static WORD_COK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["cookies"]],
     range: 3..=3,
 };
 
-static WORD_COI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COI_CHILDREN),
+static WORD_COI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ncedental"),
@@ -194533,12 +194533,12 @@ pub static WORD_COI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_COH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COH_CHILDREN),
+static WORD_COH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COH_CHILDREN),
     value: None,
 };
 
-pub static WORD_COH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abitating"),
         dictgen::InsensitiveStr::Ascii("erance"),
@@ -194558,12 +194558,12 @@ pub static WORD_COH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_COG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COG_CHILDREN),
+static WORD_COG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egen"),
         dictgen::InsensitiveStr::Ascii("into"),
@@ -194583,12 +194583,12 @@ pub static WORD_COG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_COF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COF_CHILDREN),
+static WORD_COF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COF_CHILDREN),
     value: None,
 };
 
-pub static WORD_COF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ee"),
         dictgen::InsensitiveStr::Ascii("eee"),
@@ -194648,12 +194648,12 @@ pub static WORD_COF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_COE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COE_CHILDREN),
+static WORD_COE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efficients"),
         dictgen::InsensitiveStr::Ascii("ffcient"),
@@ -194749,12 +194749,12 @@ pub static WORD_COE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_COD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COD_CHILDREN),
+static WORD_COD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("een"),
@@ -194804,12 +194804,12 @@ pub static WORD_COD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_COC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COC_CHILDREN),
+static WORD_COC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atenated"),
         dictgen::InsensitiveStr::Ascii("cinele"),
@@ -194861,12 +194861,12 @@ pub static WORD_COC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_COB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COB_CHILDREN),
+static WORD_COB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COB_CHILDREN),
     value: None,
 };
 
-pub static WORD_COB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ining"),
         dictgen::InsensitiveStr::Ascii("vers"),
@@ -194875,12 +194875,12 @@ pub static WORD_COB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_COA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COA_CHILDREN),
+static WORD_COA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COA_CHILDREN),
     value: None,
 };
 
-static WORD_COA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_COAC_NODE),
@@ -194909,23 +194909,23 @@ static WORD_COA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COAS_CHILDREN),
+static WORD_COAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lescing")],
     values: &[&["coalescing"]],
     range: 7..=7,
 };
 
-static WORD_COAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COAL_CHILDREN),
+static WORD_COAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COAL_CHILDREN),
     value: None,
 };
 
-static WORD_COAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COALA_NODE),
     None,
     Some(&WORD_COALC_NODE),
@@ -194954,12 +194954,12 @@ static WORD_COAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALS_CHILDREN),
+static WORD_COALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cece"),
@@ -194985,12 +194985,12 @@ pub static WORD_COALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_COALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALL_CHILDREN),
+static WORD_COALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ates"),
@@ -195062,12 +195062,12 @@ pub static WORD_COALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALE_CHILDREN),
+static WORD_COALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sc"),
         dictgen::InsensitiveStr::Ascii("scsing"),
@@ -195095,12 +195095,12 @@ pub static WORD_COALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_COALC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALC_CHILDREN),
+static WORD_COALC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ece"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -195109,12 +195109,12 @@ pub static WORD_COALC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_COALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALA_CHILDREN),
+static WORD_COALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cece"),
@@ -195156,23 +195156,23 @@ pub static WORD_COALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COAC_CHILDREN),
+static WORD_COAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hig")],
     values: &[&["coaching"]],
     range: 3..=3,
 };
 
-static WORD_CN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CN_CHILDREN),
+static WORD_CN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("annel"),
@@ -195212,12 +195212,12 @@ pub static WORD_CN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_CM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CM_CHILDREN),
+static WORD_CM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("mand"),
@@ -195243,12 +195243,12 @@ pub static WORD_CM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_CL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CL_CHILDREN),
+static WORD_CL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CL_CHILDREN),
     value: None,
 };
 
-static WORD_CL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CLA_NODE),
     None,
     Some(&WORD_CLC_NODE),
@@ -195277,12 +195277,12 @@ static WORD_CL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLY_CHILDREN),
+static WORD_CLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amore"),
         dictgen::InsensitiveStr::Ascii("inder"),
@@ -195291,12 +195291,12 @@ pub static WORD_CLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_CLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLU_CHILDREN),
+static WORD_CLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ases"),
@@ -195340,12 +195340,12 @@ pub static WORD_CLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_CLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLS_CHILDREN),
+static WORD_CLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asified"),
         dictgen::InsensitiveStr::Ascii("oe"),
@@ -195365,23 +195365,23 @@ pub static WORD_CLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CLP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLP_CHILDREN),
+static WORD_CLP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("board")],
     values: &[&["clipboard"]],
     range: 5..=5,
 };
 
-static WORD_CLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLO_CHILDREN),
+static WORD_CLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("acks"),
@@ -195477,12 +195477,12 @@ pub static WORD_CLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_CLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLL_CHILDREN),
+static WORD_CLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLL_CHILDREN),
     value: Some(&["call"]),
 };
 
-pub static WORD_CLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oud"),
         dictgen::InsensitiveStr::Ascii("ouded"),
@@ -195500,12 +195500,12 @@ pub static WORD_CLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_CLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CLI_CHILDREN),
+static WORD_CLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CLI_CHILDREN),
     value: None,
 };
 
-static WORD_CLI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CLI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CLIA_NODE),
     Some(&WORD_CLIB_NODE),
     Some(&WORD_CLIC_NODE),
@@ -195534,12 +195534,12 @@ static WORD_CLI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CLIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIU_CHILDREN),
+static WORD_CLIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -195549,12 +195549,12 @@ pub static WORD_CLIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CLIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIT_CHILDREN),
+static WORD_CLIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iros"),
         dictgen::InsensitiveStr::Ascii("oridis"),
@@ -195576,12 +195576,12 @@ pub static WORD_CLIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CLIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIS_CHILDREN),
+static WORD_CLIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hay"),
         dictgen::InsensitiveStr::Ascii("hays"),
@@ -195592,12 +195592,12 @@ pub static WORD_CLIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CLIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIP_CHILDREN),
+static WORD_CLIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baord"),
         dictgen::InsensitiveStr::Ascii("boad"),
@@ -195623,12 +195623,12 @@ pub static WORD_CLIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CLIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIN_CHILDREN),
+static WORD_CLIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cial"),
         dictgen::InsensitiveStr::Ascii("cially"),
@@ -195654,12 +195654,12 @@ pub static WORD_CLIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CLIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIM_CHILDREN),
+static WORD_CLIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ateers"),
         dictgen::InsensitiveStr::Ascii("atiser"),
@@ -195681,12 +195681,12 @@ pub static WORD_CLIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CLIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIK_CHILDREN),
+static WORD_CLIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIK_CHILDREN),
     value: Some(&["click"]),
 };
 
-pub static WORD_CLIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cbait"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -195695,12 +195695,12 @@ pub static WORD_CLIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CLIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIF_CHILDREN),
+static WORD_CLIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fbanger"),
         dictgen::InsensitiveStr::Ascii("fhager"),
@@ -195718,12 +195718,12 @@ pub static WORD_CLIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_CLIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIE_CHILDREN),
+static WORD_CLIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -195743,12 +195743,12 @@ pub static WORD_CLIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CLIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIC_CHILDREN),
+static WORD_CLIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kare"),
         dictgen::InsensitiveStr::Ascii("kbat"),
@@ -195766,12 +195766,12 @@ pub static WORD_CLIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_CLIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIB_CHILDREN),
+static WORD_CLIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oard"),
         dictgen::InsensitiveStr::Ascii("oards"),
@@ -195787,12 +195787,12 @@ pub static WORD_CLIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CLIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIA_CHILDREN),
+static WORD_CLIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mtes"),
@@ -195802,23 +195802,23 @@ pub static WORD_CLIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CLH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLH_CHILDREN),
+static WORD_CLH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orine")],
     values: &[&["chlorine"]],
     range: 5..=5,
 };
 
-static WORD_CLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CLE_CHILDREN),
+static WORD_CLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CLE_CHILDREN),
     value: None,
 };
 
-static WORD_CLE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CLE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CLEA_NODE),
     None,
     Some(&WORD_CLEC_NODE),
@@ -195847,12 +195847,12 @@ static WORD_CLE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CLEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEV_CHILDREN),
+static WORD_CLEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elry"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -195863,23 +195863,23 @@ pub static WORD_CLEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CLET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLET_CHILDREN),
+static WORD_CLET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLET_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ics")],
     values: &[&["celtics"]],
     range: 3..=3,
 };
 
-static WORD_CLES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLES_CHILDREN),
+static WORD_CLES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -195889,12 +195889,12 @@ pub static WORD_CLES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CLER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLER_CHILDREN),
+static WORD_CLER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLER_CHILDREN),
     value: Some(&["clear"]),
 };
 
-pub static WORD_CLER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ification"),
@@ -195903,12 +195903,12 @@ pub static WORD_CLER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CLEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEN_CHILDREN),
+static WORD_CLEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEN_CHILDREN),
     value: Some(&["clan", "clean"]),
 };
 
-pub static WORD_CLEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("aser"),
@@ -195934,12 +195934,12 @@ pub static WORD_CLEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CLEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEI_CHILDREN),
+static WORD_CLEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("nts"),
@@ -195948,23 +195948,23 @@ pub static WORD_CLEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CLEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEF_CHILDREN),
+static WORD_CLEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("f")],
     values: &[&["clef"]],
     range: 1..=1,
 };
 
-static WORD_CLEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEE_CHILDREN),
+static WORD_CLEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -195988,23 +195988,23 @@ pub static WORD_CLEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CLEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEC_CHILDREN),
+static WORD_CLEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["check"]],
     range: 1..=1,
 };
 
-static WORD_CLEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEA_CHILDREN),
+static WORD_CLEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEA_CHILDREN),
     value: Some(&["clean"]),
 };
 
-pub static WORD_CLEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -196104,12 +196104,12 @@ pub static WORD_CLEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLC_CHILDREN),
+static WORD_CLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oksource"),
         dictgen::InsensitiveStr::Ascii("osed"),
@@ -196118,12 +196118,12 @@ pub static WORD_CLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_CLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CLA_CHILDREN),
+static WORD_CLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CLA_CHILDREN),
     value: None,
 };
 
-static WORD_CLA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CLA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CLAA_NODE),
     None,
     Some(&WORD_CLAC_NODE),
@@ -196152,12 +196152,12 @@ static WORD_CLA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CLAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAY_CHILDREN),
+static WORD_CLAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mer"),
         dictgen::InsensitiveStr::Ascii("moe"),
@@ -196166,12 +196166,12 @@ pub static WORD_CLAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_CLAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAU_CHILDREN),
+static WORD_CLAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("sens"),
@@ -196180,23 +196180,23 @@ pub static WORD_CLAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CLAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAT_CHILDREN),
+static WORD_CLAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ified")],
     values: &[&["clarified"]],
     range: 5..=5,
 };
 
-static WORD_CLAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAS_CHILDREN),
+static WORD_CLAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAS_CHILDREN),
     value: Some(&["class"]),
 };
 
-pub static WORD_CLAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -196290,12 +196290,12 @@ pub static WORD_CLAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_CLAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAR_CHILDREN),
+static WORD_CLAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avoyant"),
         dictgen::InsensitiveStr::Ascii("avoyantes"),
@@ -196327,12 +196327,12 @@ pub static WORD_CLAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CLAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAN_CHILDREN),
+static WORD_CLAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("and"),
         dictgen::InsensitiveStr::Ascii("nand"),
@@ -196341,12 +196341,12 @@ pub static WORD_CLAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CLAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAM_CHILDREN),
+static WORD_CLAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("mer"),
@@ -196362,12 +196362,12 @@ pub static WORD_CLAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CLAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAI_CHILDREN),
+static WORD_CLAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bre"),
         dictgen::InsensitiveStr::Ascii("bscale"),
@@ -196399,23 +196399,23 @@ pub static WORD_CLAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CLAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAG_CHILDREN),
+static WORD_CLAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ary")],
     values: &[&["calgary"]],
     range: 3..=3,
 };
 
-static WORD_CLAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAE_CHILDREN),
+static WORD_CLAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rer"),
@@ -196425,12 +196425,12 @@ pub static WORD_CLAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CLAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAC_CHILDREN),
+static WORD_CLAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ium"),
         dictgen::InsensitiveStr::Ascii("ulate"),
@@ -196452,23 +196452,23 @@ pub static WORD_CLAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CLAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAA_CHILDREN),
+static WORD_CLAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["classes"]],
     range: 2..=2,
 };
 
-static WORD_CK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CK_CHILDREN),
+static WORD_CK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eck"),
         dictgen::InsensitiveStr::Ascii("ecksum"),
@@ -196478,12 +196478,12 @@ pub static WORD_CK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_CJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CJ_CHILDREN),
+static WORD_CJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("anged"),
@@ -196501,12 +196501,12 @@ pub static WORD_CJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_CI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CI_CHILDREN),
+static WORD_CI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CI_CHILDREN),
     value: None,
 };
 
-static WORD_CI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CIC_NODE),
@@ -196535,12 +196535,12 @@ static WORD_CI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIV_CHILDREN),
+static WORD_CIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alasation"),
         dictgen::InsensitiveStr::Ascii("alasations"),
@@ -196632,12 +196632,12 @@ pub static WORD_CIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=10,
 };
 
-static WORD_CIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIT_CHILDREN),
+static WORD_CIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icenship"),
         dictgen::InsensitiveStr::Ascii("isenship"),
@@ -196647,12 +196647,12 @@ pub static WORD_CIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=8,
 };
 
-static WORD_CIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CIR_CHILDREN),
+static WORD_CIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CIR_CHILDREN),
     value: None,
 };
 
-static WORD_CIR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CIR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CIRC_NODE),
@@ -196681,12 +196681,12 @@ static WORD_CIR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CIRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRU_CHILDREN),
+static WORD_CIRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("cit"),
@@ -196730,12 +196730,12 @@ pub static WORD_CIRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CIRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRT_CHILDREN),
+static WORD_CIRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cuit"),
         dictgen::InsensitiveStr::Ascii("icise"),
@@ -196745,23 +196745,23 @@ pub static WORD_CIRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_CIRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRS_CHILDREN),
+static WORD_CIRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("umstances")],
     values: &[&["circumstances"]],
     range: 9..=9,
 };
 
-static WORD_CIRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRR_CHILDREN),
+static WORD_CIRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ently"),
         dictgen::InsensitiveStr::Ascii("iculum"),
@@ -196771,23 +196771,23 @@ pub static WORD_CIRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CIRQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRQ_CHILDREN),
+static WORD_CIRQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uit")],
     values: &[&["circuit"]],
     range: 3..=3,
 };
 
-static WORD_CIRL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRL_CHILDREN),
+static WORD_CIRL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -196805,12 +196805,12 @@ pub static WORD_CIRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CIRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRI_CHILDREN),
+static WORD_CIRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cle"),
         dictgen::InsensitiveStr::Ascii("cles"),
@@ -196860,12 +196860,12 @@ pub static WORD_CIRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_CIRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CIRC_CHILDREN),
+static WORD_CIRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CIRC_CHILDREN),
     value: None,
 };
 
-static WORD_CIRC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CIRC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -196894,12 +196894,12 @@ static WORD_CIRC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CIRCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCU_CHILDREN),
+static WORD_CIRCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("altion"),
@@ -197025,12 +197025,12 @@ pub static WORD_CIRCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_CIRCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCO_CHILDREN),
+static WORD_CIRCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mference"),
         dictgen::InsensitiveStr::Ascii("mstance"),
@@ -197050,12 +197050,12 @@ pub static WORD_CIRCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_CIRCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCL_CHILDREN),
+static WORD_CIRCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebs"),
         dictgen::InsensitiveStr::Ascii("uar"),
@@ -197073,23 +197073,23 @@ pub static WORD_CIRCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CIRCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCK_CHILDREN),
+static WORD_CIRCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ets")],
     values: &[&["crickets"]],
     range: 3..=3,
 };
 
-static WORD_CIRCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCI_CHILDREN),
+static WORD_CIRCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mcised"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -197100,23 +197100,23 @@ pub static WORD_CIRCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CIRCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCE_CHILDREN),
+static WORD_CIRCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ls")],
     values: &[&["circles"]],
     range: 2..=2,
 };
 
-static WORD_CIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIP_CHILDREN),
+static WORD_CIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("board"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -197164,12 +197164,12 @@ pub static WORD_CIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_CIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIO_CHILDREN),
+static WORD_CIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntrol"),
         dictgen::InsensitiveStr::Ascii("tee"),
@@ -197179,12 +197179,12 @@ pub static WORD_CIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_CIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIN_CHILDREN),
+static WORD_CIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cinatti"),
         dictgen::InsensitiveStr::Ascii("cinnasti"),
@@ -197228,12 +197228,12 @@ pub static WORD_CIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_CIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIM_CHILDREN),
+static WORD_CIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etric"),
         dictgen::InsensitiveStr::Ascii("etrical"),
@@ -197293,12 +197293,12 @@ pub static WORD_CIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_CIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIL_CHILDREN),
+static WORD_CIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anto"),
         dictgen::InsensitiveStr::Ascii("dren"),
@@ -197344,12 +197344,12 @@ pub static WORD_CIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_CIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIH_CHILDREN),
+static WORD_CIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("pher"),
@@ -197359,12 +197359,12 @@ pub static WORD_CIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_CIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIG_CHILDREN),
+static WORD_CIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arattes"),
         dictgen::InsensitiveStr::Ascii("arete"),
@@ -197410,12 +197410,12 @@ pub static WORD_CIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_CIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIE_CHILDREN),
+static WORD_CIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ling"),
         dictgen::InsensitiveStr::Ascii("lings"),
@@ -197426,12 +197426,12 @@ pub static WORD_CIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIC_CHILDREN),
+static WORD_CIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("k"),
         dictgen::InsensitiveStr::Ascii("rle"),
@@ -197453,12 +197453,12 @@ pub static WORD_CIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_CH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CH_CHILDREN),
+static WORD_CH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CH_CHILDREN),
     value: None,
 };
 
-static WORD_CH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHA_NODE),
     None,
     Some(&WORD_CHC_NODE),
@@ -197487,12 +197487,12 @@ static WORD_CH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHU_CHILDREN),
+static WORD_CHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bks"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -197530,23 +197530,23 @@ pub static WORD_CHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHT_CHILDREN),
+static WORD_CHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ulhu")],
     values: &[&["cthulhu"]],
     range: 4..=4,
 };
 
-static WORD_CHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHR_CHILDREN),
+static WORD_CHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -197680,12 +197680,12 @@ pub static WORD_CHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_CHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHO_CHILDREN),
+static WORD_CHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atic"),
         dictgen::InsensitiveStr::Ascii("calates"),
@@ -197809,12 +197809,12 @@ pub static WORD_CHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_CHN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHN_CHILDREN),
+static WORD_CHN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("age"),
@@ -197856,23 +197856,23 @@ pub static WORD_CHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CHM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHM_CHILDREN),
+static WORD_CHM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("abers")],
     values: &[&["chambers"]],
     range: 5..=5,
 };
 
-static WORD_CHL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHL_CHILDREN),
+static WORD_CHL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esea"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -197898,23 +197898,23 @@ pub static WORD_CHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_CHK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHK_CHILDREN),
+static WORD_CHK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["checked"]],
     range: 2..=2,
 };
 
-static WORD_CHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHI_CHILDREN),
+static WORD_CHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHI_CHILDREN),
     value: None,
 };
 
-static WORD_CHI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHIA_NODE),
     None,
     None,
@@ -197943,12 +197943,12 @@ static WORD_CHI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHIZ_NODE),
 ];
 
-static WORD_CHIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIZ_CHILDREN),
+static WORD_CHIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ell"),
         dictgen::InsensitiveStr::Ascii("elle"),
@@ -198010,12 +198010,12 @@ pub static WORD_CHIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CHIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIV_CHILDREN),
+static WORD_CHIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aly"),
         dictgen::InsensitiveStr::Ascii("arly"),
@@ -198025,12 +198025,12 @@ pub static WORD_CHIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CHIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIU_CHILDREN),
+static WORD_CHIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hahua"),
         dictgen::InsensitiveStr::Ascii("ldren"),
@@ -198039,12 +198039,12 @@ pub static WORD_CHIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_CHIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIS_CHILDREN),
+static WORD_CHIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ell"),
         dictgen::InsensitiveStr::Ascii("elle"),
@@ -198076,12 +198076,12 @@ pub static WORD_CHIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIR_CHILDREN),
+static WORD_CHIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stian"),
         dictgen::InsensitiveStr::Ascii("stianity"),
@@ -198097,12 +198097,12 @@ pub static WORD_CHIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_CHIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIP_CHILDREN),
+static WORD_CHIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -198134,12 +198134,12 @@ pub static WORD_CHIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CHIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIO_CHILDREN),
+static WORD_CHIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("p"),
@@ -198148,12 +198148,12 @@ pub static WORD_CHIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CHIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIN_CHILDREN),
+static WORD_CHIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ees"),
         dictgen::InsensitiveStr::Ascii("eese"),
@@ -198171,12 +198171,12 @@ pub static WORD_CHIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CHIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIM_CHILDREN),
+static WORD_CHIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eny"),
         dictgen::InsensitiveStr::Ascii("menies"),
@@ -198186,12 +198186,12 @@ pub static WORD_CHIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIL_CHILDREN),
+static WORD_CHIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dbird"),
         dictgen::InsensitiveStr::Ascii("dbrith"),
@@ -198243,12 +198243,12 @@ pub static WORD_CHIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CHIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIH_CHILDREN),
+static WORD_CHIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("auhua"),
         dictgen::InsensitiveStr::Ascii("uaha"),
@@ -198266,23 +198266,23 @@ pub static WORD_CHIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_CHIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIE_CHILDREN),
+static WORD_CHIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nse")],
     values: &[&["chinese"]],
     range: 3..=3,
 };
 
-static WORD_CHID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHID_CHILDREN),
+static WORD_CHID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHID_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lbirth"),
         dictgen::InsensitiveStr::Ascii("lfree"),
@@ -198302,34 +198302,34 @@ pub static WORD_CHID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIA_CHILDREN),
+static WORD_CHIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nsaw")],
     values: &[&["chainsaw"]],
     range: 4..=4,
 };
 
-static WORD_CHH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHH_CHILDREN),
+static WORD_CHH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ange")],
     values: &[&["change"]],
     range: 4..=4,
 };
 
-static WORD_CHG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHG_CHILDREN),
+static WORD_CHG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("anged"),
@@ -198340,12 +198340,12 @@ pub static WORD_CHG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_CHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHE_CHILDREN),
+static WORD_CHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHE_CHILDREN),
     value: None,
 };
 
-static WORD_CHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHEA_NODE),
     None,
     Some(&WORD_CHEC_NODE),
@@ -198374,12 +198374,12 @@ static WORD_CHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHES_CHILDREN),
+static WORD_CHES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cksums"),
         dictgen::InsensitiveStr::Ascii("lea"),
@@ -198388,12 +198388,12 @@ pub static WORD_CHES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHER_CHILDREN),
+static WORD_CHER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHER_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ching"),
@@ -198427,12 +198427,12 @@ pub static WORD_CHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEN_CHILDREN),
+static WORD_CHEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ged"),
         dictgen::InsensitiveStr::Ascii("nel"),
@@ -198441,12 +198441,12 @@ pub static WORD_CHEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_CHEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEM_CHILDREN),
+static WORD_CHEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cial"),
         dictgen::InsensitiveStr::Ascii("cially"),
@@ -198466,12 +198466,12 @@ pub static WORD_CHEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CHEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEL_CHILDREN),
+static WORD_CHEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lo"),
         dictgen::InsensitiveStr::Ascii("sae"),
@@ -198480,12 +198480,12 @@ pub static WORD_CHEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CHEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEK_CHILDREN),
+static WORD_CHEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEK_CHILDREN),
     value: Some(&["check"]),
 };
 
-pub static WORD_CHEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cer"),
@@ -198521,12 +198521,12 @@ pub static WORD_CHEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CHEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEI_CHILDREN),
+static WORD_CHEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("fs"),
@@ -198535,12 +198535,12 @@ pub static WORD_CHEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CHEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEE_CHILDREN),
+static WORD_CHEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ck"),
         dictgen::InsensitiveStr::Ascii("ots"),
@@ -198608,23 +198608,23 @@ pub static WORD_CHEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CHED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHED_CHILDREN),
+static WORD_CHED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uling")],
     values: &[&["scheduling"]],
     range: 5..=5,
 };
 
-static WORD_CHEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEC_CHILDREN),
+static WORD_CHEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEC_CHILDREN),
     value: Some(&["check"]),
 };
 
-pub static WORD_CHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("box"),
         dictgen::InsensitiveStr::Ascii("boxes"),
@@ -198738,12 +198738,12 @@ pub static WORD_CHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CHEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEA_CHILDREN),
+static WORD_CHEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("peast"),
         dictgen::InsensitiveStr::Ascii("tta"),
@@ -198752,12 +198752,12 @@ pub static WORD_CHEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CHC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHC_CHILDREN),
+static WORD_CHC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ek"),
         dictgen::InsensitiveStr::Ascii("eked"),
@@ -198779,12 +198779,12 @@ pub static WORD_CHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_CHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHA_CHILDREN),
+static WORD_CHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHA_CHILDREN),
     value: None,
 };
 
-static WORD_CHA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHAA_NODE),
     None,
     Some(&WORD_CHAC_NODE),
@@ -198813,23 +198813,23 @@ static WORD_CHA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAW_CHILDREN),
+static WORD_CHAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["chalk"]],
     range: 1..=1,
 };
 
-static WORD_CHAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAT_CHILDREN),
+static WORD_CHAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -198873,12 +198873,12 @@ pub static WORD_CHAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CHAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAS_CHILDREN),
+static WORD_CHAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iers"),
         dictgen::InsensitiveStr::Ascii("im"),
@@ -198912,12 +198912,12 @@ pub static WORD_CHAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CHAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHAR_CHILDREN),
+static WORD_CHAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHAR_CHILDREN),
     value: None,
 };
 
-static WORD_CHAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHARA_NODE),
     None,
     Some(&WORD_CHARC_NODE),
@@ -198946,12 +198946,12 @@ static WORD_CHAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHART_CHILDREN),
+static WORD_CHART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHART_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("roose"),
@@ -198960,12 +198960,12 @@ pub static WORD_CHART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_CHARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARS_CHILDREN),
+static WORD_CHARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ima"),
         dictgen::InsensitiveStr::Ascii("imatic"),
@@ -198974,34 +198974,34 @@ pub static WORD_CHARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARO_CHILDREN),
+static WORD_CHARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cal")],
     values: &[&["charcoal"]],
     range: 3..=3,
 };
 
-static WORD_CHARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARM_CHILDREN),
+static WORD_CHARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("isa")],
     values: &[&["charisma"]],
     range: 3..=3,
 };
 
-static WORD_CHARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARI_CHILDREN),
+static WORD_CHARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARI_CHILDREN),
     value: Some(&["chair"]),
 };
 
-pub static WORD_CHARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cter"),
         dictgen::InsensitiveStr::Ascii("cterization"),
@@ -199041,12 +199041,12 @@ pub static WORD_CHARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_CHARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARG_CHILDREN),
+static WORD_CHARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ehr"),
         dictgen::InsensitiveStr::Ascii("eur"),
@@ -199056,12 +199056,12 @@ pub static WORD_CHARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_CHARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARE_CHILDREN),
+static WORD_CHARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cter"),
         dictgen::InsensitiveStr::Ascii("cteristic"),
@@ -199081,12 +199081,12 @@ pub static WORD_CHARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_CHARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARC_CHILDREN),
+static WORD_CHARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aol"),
         dictgen::InsensitiveStr::Ascii("ater"),
@@ -199114,12 +199114,12 @@ pub static WORD_CHARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CHARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHARA_CHILDREN),
+static WORD_CHARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHARA_CHILDREN),
     value: None,
 };
 
-static WORD_CHARA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHARA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CHARAC_NODE),
@@ -199148,12 +199148,12 @@ static WORD_CHARA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHARAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARAT_CHILDREN),
+static WORD_CHARAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("cer"),
@@ -199177,12 +199177,12 @@ pub static WORD_CHARAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CHARAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARAS_CHILDREN),
+static WORD_CHARAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARAS_CHILDREN),
     value: Some(&["chars"]),
 };
 
-pub static WORD_CHARAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cter"),
         dictgen::InsensitiveStr::Ascii("cters"),
@@ -199202,12 +199202,12 @@ pub static WORD_CHARAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CHARAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARAR_CHILDREN),
+static WORD_CHARAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -199223,12 +199223,12 @@ pub static WORD_CHARAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_CHARAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARAK_CHILDREN),
+static WORD_CHARAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ter"),
         dictgen::InsensitiveStr::Ascii("ters"),
@@ -199237,12 +199237,12 @@ pub static WORD_CHARAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_CHARAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHARAC_CHILDREN),
+static WORD_CHARAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHARAC_CHILDREN),
     value: None,
 };
 
-static WORD_CHARAC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHARAC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHARACA_NODE),
     None,
     None,
@@ -199271,23 +199271,23 @@ static WORD_CHARAC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHARACY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACY_CHILDREN),
+static WORD_CHARACY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ers")],
     values: &[&["characters"]],
     range: 3..=3,
 };
 
-static WORD_CHARACT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHARACT_CHILDREN),
+static WORD_CHARACT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHARACT_CHILDREN),
     value: None,
 };
 
-static WORD_CHARACT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHARACT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHARACTA_NODE),
     None,
     None,
@@ -199316,34 +199316,34 @@ static WORD_CHARACT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHARACTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTU_CHILDREN),
+static WORD_CHARACTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("re")],
     values: &[&["character"]],
     range: 2..=2,
 };
 
-static WORD_CHARACTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTS_CHILDREN),
+static WORD_CHARACTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTS_CHILDREN),
     value: Some(&["characters"]),
 };
 
-pub static WORD_CHARACTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_CHARACTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTR_CHILDREN),
+static WORD_CHARACTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTR_CHILDREN),
     value: Some(&["character"]),
 };
 
-pub static WORD_CHARACTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("istic"),
@@ -199361,12 +199361,12 @@ pub static WORD_CHARACTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=9,
 };
 
-static WORD_CHARACTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTO_CHILDREN),
+static WORD_CHARACTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ristics"),
@@ -199376,12 +199376,12 @@ pub static WORD_CHARACTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=7,
 };
 
-static WORD_CHARACTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTI_CHILDREN),
+static WORD_CHARACTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ristic"),
         dictgen::InsensitiveStr::Ascii("ristically"),
@@ -199395,23 +199395,23 @@ pub static WORD_CHARACTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 6..=10,
 };
 
-static WORD_CHARACTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTH_CHILDREN),
+static WORD_CHARACTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["character"]],
     range: 2..=2,
 };
 
-static WORD_CHARACTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTE_CHILDREN),
+static WORD_CHARACTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTE_CHILDREN),
     value: Some(&["character"]),
 };
 
-pub static WORD_CHARACTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -199533,12 +199533,12 @@ pub static WORD_CHARACTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=11,
 };
 
-static WORD_CHARACTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTA_CHILDREN),
+static WORD_CHARACTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ristic"),
@@ -199560,23 +199560,23 @@ pub static WORD_CHARACTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_CHARACS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACS_CHILDREN),
+static WORD_CHARACS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tyle")],
     values: &[&["charstyle"]],
     range: 4..=4,
 };
 
-static WORD_CHARACH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACH_CHILDREN),
+static WORD_CHARACH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -199592,23 +199592,23 @@ pub static WORD_CHARACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_CHARACG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACG_CHILDREN),
+static WORD_CHARACG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["character"]],
     range: 3..=3,
 };
 
-static WORD_CHARACE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACE_CHILDREN),
+static WORD_CHARACE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -199628,12 +199628,12 @@ pub static WORD_CHARACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=4,
 };
 
-static WORD_CHARACA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACA_CHILDREN),
+static WORD_CHARACA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ter"),
         dictgen::InsensitiveStr::Ascii("ters"),
@@ -199642,23 +199642,23 @@ pub static WORD_CHARACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_CHAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAP_CHILDREN),
+static WORD_CHAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["chapter"]],
     range: 2..=2,
 };
 
-static WORD_CHAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHAN_CHILDREN),
+static WORD_CHAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHAN_CHILDREN),
     value: None,
 };
 
-static WORD_CHAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHANA_NODE),
     None,
     Some(&WORD_CHANC_NODE),
@@ -199687,12 +199687,12 @@ static WORD_CHAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANS_CHILDREN),
+static WORD_CHANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ellor"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -199701,12 +199701,12 @@ pub static WORD_CHANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHANP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANP_CHILDREN),
+static WORD_CHANP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ionship"),
         dictgen::InsensitiveStr::Ascii("ionships"),
@@ -199715,12 +199715,12 @@ pub static WORD_CHANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_CHANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANN_CHILDREN),
+static WORD_CHANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ael"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -199756,12 +199756,12 @@ pub static WORD_CHANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CHANL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANL_CHILDREN),
+static WORD_CHANL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("lenge"),
@@ -199771,12 +199771,12 @@ pub static WORD_CHANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CHANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANI_CHILDREN),
+static WORD_CHANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ned"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -199792,12 +199792,12 @@ pub static WORD_CHANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANG_CHILDREN),
+static WORD_CHANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -199839,12 +199839,12 @@ pub static WORD_CHANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CHANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANE_CHILDREN),
+static WORD_CHANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANE_CHILDREN),
     value: Some(&["change", "chain"]),
 };
 
-pub static WORD_CHANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -199864,12 +199864,12 @@ pub static WORD_CHANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CHAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAND_CHILDREN),
+static WORD_CHAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aleer"),
         dictgen::InsensitiveStr::Ascii("aleers"),
@@ -199891,12 +199891,12 @@ pub static WORD_CHAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CHANC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANC_CHILDREN),
+static WORD_CHANC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -199918,12 +199918,12 @@ pub static WORD_CHANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANA_CHILDREN),
+static WORD_CHANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -199941,12 +199941,12 @@ pub static WORD_CHANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_CHAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAM_CHILDREN),
+static WORD_CHAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bear"),
         dictgen::InsensitiveStr::Ascii("bre"),
@@ -200000,12 +200000,12 @@ pub static WORD_CHAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CHAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAL_CHILDREN),
+static WORD_CHAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enges"),
         dictgen::InsensitiveStr::Ascii("enging"),
@@ -200061,12 +200061,12 @@ pub static WORD_CHAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CHAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAI_CHILDREN),
+static WORD_CHAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -200077,12 +200077,12 @@ pub static WORD_CHAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CHAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAH_CHILDREN),
+static WORD_CHAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ged"),
         dictgen::InsensitiveStr::Ascii("ging"),
@@ -200091,12 +200091,12 @@ pub static WORD_CHAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CHAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAG_CHILDREN),
+static WORD_CHAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -200118,12 +200118,12 @@ pub static WORD_CHAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CHAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAE_CHILDREN),
+static WORD_CHAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ck"),
         dictgen::InsensitiveStr::Ascii("cked"),
@@ -200141,12 +200141,12 @@ pub static WORD_CHAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAC_CHILDREN),
+static WORD_CHAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -200168,12 +200168,12 @@ pub static WORD_CHAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CHAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAA_CHILDREN),
+static WORD_CHAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rcter"),
         dictgen::InsensitiveStr::Ascii("rcters"),
@@ -200183,23 +200183,23 @@ pub static WORD_CHAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CG_CHILDREN),
+static WORD_CG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ywin")],
     values: &[&["cygwin"]],
     range: 4..=4,
 };
 
-static WORD_CE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CE_CHILDREN),
+static WORD_CE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CE_CHILDREN),
     value: None,
 };
 
-static WORD_CE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CEA_NODE),
     None,
     Some(&WORD_CEC_NODE),
@@ -200228,12 +200228,12 @@ static WORD_CE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CET_CHILDREN),
+static WORD_CET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CET_CHILDREN),
     value: None,
 };
 
-pub static WORD_CET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainly"),
@@ -200253,12 +200253,12 @@ pub static WORD_CET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_CES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CES_CHILDREN),
+static WORD_CES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sationalism"),
         dictgen::InsensitiveStr::Ascii("sationalist"),
@@ -200274,12 +200274,12 @@ pub static WORD_CES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_CER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CER_CHILDREN),
+static WORD_CER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CER_CHILDREN),
     value: None,
 };
 
-static WORD_CER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CERA_NODE),
     Some(&WORD_CERB_NODE),
     Some(&WORD_CERC_NODE),
@@ -200308,23 +200308,23 @@ static WORD_CER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERV_CHILDREN),
+static WORD_CERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ial")],
     values: &[&["cervical", "servile", "serval"]],
     range: 3..=3,
 };
 
-static WORD_CERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CERT_CHILDREN),
+static WORD_CERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CERT_CHILDREN),
     value: None,
 };
 
-static WORD_CERT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CERT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CERTA_NODE),
     None,
     None,
@@ -200353,12 +200353,12 @@ static WORD_CERT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CERTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERTI_CHILDREN),
+static WORD_CERTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERTI_CHILDREN),
     value: Some(&["certificate", "certify"]),
 };
 
-pub static WORD_CERTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainly"),
@@ -200484,12 +200484,12 @@ pub static WORD_CERTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_CERTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERTF_CHILDREN),
+static WORD_CERTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icate"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -200521,23 +200521,23 @@ pub static WORD_CERTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CERTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERTE_CHILDREN),
+static WORD_CERTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rn")],
     values: &[&["certain"]],
     range: 2..=2,
 };
 
-static WORD_CERTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERTA_CHILDREN),
+static WORD_CERTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ily"),
         dictgen::InsensitiveStr::Ascii("incy"),
@@ -200569,12 +200569,12 @@ pub static WORD_CERTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERR_CHILDREN),
+static WORD_CERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebral"),
         dictgen::InsensitiveStr::Ascii("ebrally"),
@@ -200583,23 +200583,23 @@ pub static WORD_CERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERO_CHILDREN),
+static WORD_CERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mony")],
     values: &[&["ceremony"]],
     range: 4..=4,
 };
 
-static WORD_CERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERN_CHILDREN),
+static WORD_CERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omial"),
         dictgen::InsensitiveStr::Ascii("omially"),
@@ -200615,12 +200615,12 @@ pub static WORD_CERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERM_CHILDREN),
+static WORD_CERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aic"),
         dictgen::InsensitiveStr::Ascii("onial"),
@@ -200638,12 +200638,12 @@ pub static WORD_CERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERI_CHILDREN),
+static WORD_CERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ficate"),
         dictgen::InsensitiveStr::Ascii("fication"),
@@ -200685,12 +200685,12 @@ pub static WORD_CERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERE_CHILDREN),
+static WORD_CERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("brawl"),
@@ -200710,12 +200710,12 @@ pub static WORD_CERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERC_CHILDREN),
+static WORD_CERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omstance"),
         dictgen::InsensitiveStr::Ascii("omstances"),
@@ -200739,12 +200739,12 @@ pub static WORD_CERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_CERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERB_CHILDREN),
+static WORD_CERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eral"),
         dictgen::InsensitiveStr::Ascii("reus"),
@@ -200754,12 +200754,12 @@ pub static WORD_CERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_CERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERA_CHILDREN),
+static WORD_CERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("inly"),
@@ -200779,12 +200779,12 @@ pub static WORD_CERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_CEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEN_CHILDREN),
+static WORD_CEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ario"),
         dictgen::InsensitiveStr::Ascii("arios"),
@@ -200886,12 +200886,12 @@ pub static WORD_CEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_CEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEM_CHILDREN),
+static WORD_CEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entary"),
         dictgen::InsensitiveStr::Ascii("etarey"),
@@ -200902,12 +200902,12 @@ pub static WORD_CEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_CEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEL_CHILDREN),
+static WORD_CEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -201009,12 +201009,12 @@ pub static WORD_CEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_CEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEH_CHILDREN),
+static WORD_CEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ck"),
         dictgen::InsensitiveStr::Ascii("cked"),
@@ -201034,12 +201034,12 @@ pub static WORD_CEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CED_CHILDREN),
+static WORD_CED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ential"),
         dictgen::InsensitiveStr::Ascii("entials"),
@@ -201048,12 +201048,12 @@ pub static WORD_CED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_CEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEC_CHILDREN),
+static WORD_CEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("k"),
         dictgen::InsensitiveStr::Ascii("ked"),
@@ -201071,12 +201071,12 @@ pub static WORD_CEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_CEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEA_CHILDREN),
+static WORD_CEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rtype"),
         dictgen::InsensitiveStr::Ascii("sar"),
@@ -201108,23 +201108,23 @@ pub static WORD_CEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CD_CHILDREN),
+static WORD_CD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ecompress")],
     values: &[&["decompress"]],
     range: 9..=9,
 };
 
-static WORD_CC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CC_CHILDREN),
+static WORD_CC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahe"),
         dictgen::InsensitiveStr::Ascii("ale"),
@@ -201174,12 +201174,12 @@ pub static WORD_CC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_CA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CA_CHILDREN),
+static WORD_CA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CA_CHILDREN),
     value: None,
 };
 
-static WORD_CA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CAA_NODE),
     Some(&WORD_CAB_NODE),
     Some(&WORD_CAC_NODE),
@@ -201208,12 +201208,12 @@ static WORD_CA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAV_CHILDREN),
+static WORD_CAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aet"),
         dictgen::InsensitiveStr::Ascii("aets"),
@@ -201233,12 +201233,12 @@ pub static WORD_CAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_CAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAU_CHILDREN),
+static WORD_CAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caisan"),
         dictgen::InsensitiveStr::Ascii("casain"),
@@ -201292,12 +201292,12 @@ pub static WORD_CAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_CAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAT_CHILDREN),
+static WORD_CAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAT_CHILDREN),
     value: None,
 };
 
-static WORD_CAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CATA_NODE),
     None,
     Some(&WORD_CATC_NODE),
@@ -201326,23 +201326,23 @@ static WORD_CAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATU_CHILDREN),
+static WORD_CATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("re")],
     values: &[&["capture"]],
     range: 2..=2,
 };
 
-static WORD_CATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATT_CHILDREN),
+static WORD_CATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erpilar"),
         dictgen::InsensitiveStr::Ascii("erpilars"),
@@ -201360,34 +201360,34 @@ pub static WORD_CATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_CATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATS_CHILDREN),
+static WORD_CATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("trophe")],
     values: &[&["catastrophe"]],
     range: 6..=6,
 };
 
-static WORD_CATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATR_CHILDREN),
+static WORD_CATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("idge")],
     values: &[&["cartridge"]],
     range: 4..=4,
 };
 
-static WORD_CATP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATP_CHILDREN),
+static WORD_CATP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ture"),
         dictgen::InsensitiveStr::Ascii("ure"),
@@ -201398,12 +201398,12 @@ pub static WORD_CATP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CATO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATO_CHILDREN),
+static WORD_CATO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gerized"),
         dictgen::InsensitiveStr::Ascii("gory"),
@@ -201423,12 +201423,12 @@ pub static WORD_CATO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_CATL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATL_CHILDREN),
+static WORD_CATL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayst"),
         dictgen::InsensitiveStr::Ascii("oag"),
@@ -201439,12 +201439,12 @@ pub static WORD_CATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATI_CHILDREN),
+static WORD_CATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gorically"),
         dictgen::InsensitiveStr::Ascii("strophic"),
@@ -201454,12 +201454,12 @@ pub static WORD_CATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_CATH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATH_CHILDREN),
+static WORD_CATH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deral"),
         dictgen::InsensitiveStr::Ascii("erdal"),
@@ -201501,12 +201501,12 @@ pub static WORD_CATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CATG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATG_CHILDREN),
+static WORD_CATG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eory"),
         dictgen::InsensitiveStr::Ascii("orical"),
@@ -201524,12 +201524,12 @@ pub static WORD_CATG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATE_CHILDREN),
+static WORD_CATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gogical"),
         dictgen::InsensitiveStr::Ascii("gogically"),
@@ -201599,12 +201599,12 @@ pub static WORD_CATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATC_CHILDREN),
+static WORD_CATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("hed"),
@@ -201622,12 +201622,12 @@ pub static WORD_CATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATA_CHILDREN),
+static WORD_CATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alogue"),
         dictgen::InsensitiveStr::Ascii("clism"),
@@ -201727,12 +201727,12 @@ pub static WORD_CATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_CAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAS_CHILDREN),
+static WORD_CAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arole"),
         dictgen::InsensitiveStr::Ascii("aroles"),
@@ -201834,12 +201834,12 @@ pub static WORD_CAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_CAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAR_CHILDREN),
+static WORD_CAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAR_CHILDREN),
     value: None,
 };
 
-static WORD_CAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CARA_NODE),
     Some(&WORD_CARB_NODE),
     Some(&WORD_CARC_NODE),
@@ -201868,12 +201868,12 @@ static WORD_CAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CARY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARY_CHILDREN),
+static WORD_CARY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ons"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -201882,23 +201882,23 @@ pub static WORD_CARY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CARV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARV_CHILDREN),
+static WORD_CARV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inal")],
     values: &[&["carnival"]],
     range: 4..=4,
 };
 
-static WORD_CART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CART_CHILDREN),
+static WORD_CART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CART_CHILDREN),
     value: None,
 };
 
-pub static WORD_CART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("dridge"),
@@ -201968,12 +201968,12 @@ pub static WORD_CART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARR_CHILDREN),
+static WORD_CARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -202025,12 +202025,12 @@ pub static WORD_CARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CARP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARP_CHILDREN),
+static WORD_CARP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etner"),
         dictgen::InsensitiveStr::Ascii("tener"),
@@ -202039,12 +202039,12 @@ pub static WORD_CARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_CARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARO_CHILDREN),
+static WORD_CARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lan"),
         dictgen::InsensitiveStr::Ascii("linia"),
@@ -202066,12 +202066,12 @@ pub static WORD_CARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARN_CHILDREN),
+static WORD_CARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agie"),
         dictgen::InsensitiveStr::Ascii("avor"),
@@ -202107,12 +202107,12 @@ pub static WORD_CARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARM_CHILDREN),
+static WORD_CARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alite"),
         dictgen::InsensitiveStr::Ascii("onial"),
@@ -202132,23 +202132,23 @@ pub static WORD_CARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARL_CHILDREN),
+static WORD_CARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oina")],
     values: &[&["carolina"]],
     range: 4..=4,
 };
 
-static WORD_CARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARI_CHILDREN),
+static WORD_CARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acture"),
         dictgen::InsensitiveStr::Ascii("actures"),
@@ -202214,12 +202214,12 @@ pub static WORD_CARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_CARF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARF_CHILDREN),
+static WORD_CARF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ull"),
         dictgen::InsensitiveStr::Ascii("ully"),
@@ -202228,12 +202228,12 @@ pub static WORD_CARF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARE_CHILDREN),
+static WORD_CARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("flly"),
         dictgen::InsensitiveStr::Ascii("full"),
@@ -202251,12 +202251,12 @@ pub static WORD_CARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARD_CHILDREN),
+static WORD_CARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aic"),
         dictgen::InsensitiveStr::Ascii("baord"),
@@ -202298,12 +202298,12 @@ pub static WORD_CARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=13,
 };
 
-static WORD_CARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARC_CHILDREN),
+static WORD_CARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("iature"),
@@ -202319,12 +202319,12 @@ pub static WORD_CARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CARB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARB_CHILDREN),
+static WORD_CARB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ien"),
         dictgen::InsensitiveStr::Ascii("ohdyrates"),
@@ -202348,12 +202348,12 @@ pub static WORD_CARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARA_CHILDREN),
+static WORD_CARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("boo"),
         dictgen::InsensitiveStr::Ascii("boos"),
@@ -202385,12 +202385,12 @@ pub static WORD_CARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAP_CHILDREN),
+static WORD_CAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAP_CHILDREN),
     value: None,
 };
 
-static WORD_CAP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CAPA_NODE),
     Some(&WORD_CAPB_NODE),
     Some(&WORD_CAPC_NODE),
@@ -202419,12 +202419,12 @@ static WORD_CAP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CAPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPU_CHILDREN),
+static WORD_CAPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sle"),
         dictgen::InsensitiveStr::Ascii("sles"),
@@ -202444,12 +202444,12 @@ pub static WORD_CAPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CAPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPT_CHILDREN),
+static WORD_CAPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ainers"),
@@ -202505,12 +202505,12 @@ pub static WORD_CAPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CAPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPS_CHILDREN),
+static WORD_CAPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uels"),
         dictgen::InsensitiveStr::Ascii("ulers"),
@@ -202530,45 +202530,45 @@ pub static WORD_CAPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CAPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPR_CHILDREN),
+static WORD_CAPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enter")],
     values: &[&["carpenter"]],
     range: 5..=5,
 };
 
-static WORD_CAPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPP_CHILDREN),
+static WORD_CAPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("able")],
     values: &[&["capable"]],
     range: 4..=4,
 };
 
-static WORD_CAPM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPM_CHILDREN),
+static WORD_CAPM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bell")],
     values: &[&["campbell"]],
     range: 4..=4,
 };
 
-static WORD_CAPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPI_CHILDREN),
+static WORD_CAPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alized"),
         dictgen::InsensitiveStr::Ascii("bilities"),
@@ -202654,12 +202654,12 @@ pub static WORD_CAPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_CAPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPE_CHILDREN),
+static WORD_CAPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("la"),
         dictgen::InsensitiveStr::Ascii("rbility"),
@@ -202668,12 +202668,12 @@ pub static WORD_CAPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CAPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPC_CHILDREN),
+static WORD_CAPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acity"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -202682,12 +202682,12 @@ pub static WORD_CAPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CAPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPB_CHILDREN),
+static WORD_CAPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("ale"),
@@ -202696,12 +202696,12 @@ pub static WORD_CAPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CAPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPA_CHILDREN),
+static WORD_CAPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acity"),
         dictgen::InsensitiveStr::Ascii("bable"),
@@ -202797,12 +202797,12 @@ pub static WORD_CAPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_CAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAO_CHILDREN),
+static WORD_CAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("st"),
         dictgen::InsensitiveStr::Ascii("uld"),
@@ -202811,12 +202811,12 @@ pub static WORD_CAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_CAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAN_CHILDREN),
+static WORD_CAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAN_CHILDREN),
     value: None,
 };
 
-static WORD_CAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CANA_NODE),
     None,
     Some(&WORD_CANC_NODE),
@@ -202845,34 +202845,34 @@ static WORD_CAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CANY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANY_CHILDREN),
+static WORD_CANY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["canaille"]],
     range: 1..=1,
 };
 
-static WORD_CANV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANV_CHILDREN),
+static WORD_CANV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ase")],
     values: &[&["canvas"]],
     range: 3..=3,
 };
 
-static WORD_CANT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANT_CHILDREN),
+static WORD_CANT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -202900,34 +202900,34 @@ pub static WORD_CANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANS_CHILDREN),
+static WORD_CANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iter")],
     values: &[&["canister"]],
     range: 4..=4,
 };
 
-static WORD_CANR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANR_CHILDREN),
+static WORD_CANR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["carnage"]],
     range: 3..=3,
 };
 
-static WORD_CANO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANO_CHILDREN),
+static WORD_CANO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cical"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -202963,12 +202963,12 @@ pub static WORD_CANO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_CANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANN_CHILDREN),
+static WORD_CANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANN_CHILDREN),
     value: Some(&["can"]),
 };
 
-pub static WORD_CANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abil"),
         dictgen::InsensitiveStr::Ascii("abile"),
@@ -203056,12 +203056,12 @@ pub static WORD_CANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_CANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANI_CHILDREN),
+static WORD_CANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("date"),
         dictgen::InsensitiveStr::Ascii("dates"),
@@ -203072,12 +203072,12 @@ pub static WORD_CANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANG_CHILDREN),
+static WORD_CANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -203088,12 +203088,12 @@ pub static WORD_CANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANE_CHILDREN),
+static WORD_CANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("w"),
         dictgen::InsensitiveStr::Ascii("ws"),
@@ -203102,12 +203102,12 @@ pub static WORD_CANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAND_CHILDREN),
+static WORD_CAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adate"),
         dictgen::InsensitiveStr::Ascii("adates"),
@@ -203151,12 +203151,12 @@ pub static WORD_CAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_CANC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANC_CHILDREN),
+static WORD_CANC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elability"),
         dictgen::InsensitiveStr::Ascii("elaltion"),
@@ -203214,12 +203214,12 @@ pub static WORD_CANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANA_CHILDREN),
+static WORD_CANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bel"),
         dictgen::InsensitiveStr::Ascii("bels"),
@@ -203257,12 +203257,12 @@ pub static WORD_CANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAM_CHILDREN),
+static WORD_CAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aera"),
         dictgen::InsensitiveStr::Ascii("apign"),
@@ -203378,12 +203378,12 @@ pub static WORD_CAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_CAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAL_CHILDREN),
+static WORD_CAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAL_CHILDREN),
     value: None,
 };
 
-static WORD_CAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CALA_NODE),
     Some(&WORD_CALB_NODE),
     Some(&WORD_CALC_NODE),
@@ -203412,23 +203412,23 @@ static WORD_CAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALY_CHILDREN),
+static WORD_CALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("more")],
     values: &[&["claymore"]],
     range: 4..=4,
 };
 
-static WORD_CALU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALU_CHILDREN),
+static WORD_CALU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("calte"),
         dictgen::InsensitiveStr::Ascii("calted"),
@@ -203504,12 +203504,12 @@ pub static WORD_CALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALS_CHILDREN),
+static WORD_CALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -203527,12 +203527,12 @@ pub static WORD_CALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CALR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALR_CHILDREN),
+static WORD_CALR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ification"),
         dictgen::InsensitiveStr::Ascii("ify"),
@@ -203552,23 +203552,23 @@ pub static WORD_CALR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CALO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALO_CHILDREN),
+static WORD_CALO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ires")],
     values: &[&["calories"]],
     range: 4..=4,
 };
 
-static WORD_CALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALL_CHILDREN),
+static WORD_CALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abck"),
         dictgen::InsensitiveStr::Ascii("abcks"),
@@ -203654,12 +203654,12 @@ pub static WORD_CALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALI_CHILDREN),
+static WORD_CALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ased"),
         dictgen::InsensitiveStr::Ascii("bartion"),
@@ -203737,23 +203737,23 @@ pub static WORD_CALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CALG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALG_CHILDREN),
+static WORD_CALG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arry")],
     values: &[&["calgary"]],
     range: 4..=4,
 };
 
-static WORD_CALF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALF_CHILDREN),
+static WORD_CALF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -203762,12 +203762,12 @@ pub static WORD_CALF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALE_CHILDREN),
+static WORD_CALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -203789,12 +203789,12 @@ pub static WORD_CALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CALC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CALC_CHILDREN),
+static WORD_CALC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CALC_CHILDREN),
     value: None,
 };
 
-static WORD_CALC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CALC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CALCA_NODE),
     None,
     None,
@@ -203823,12 +203823,12 @@ static WORD_CALC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CALCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CALCU_CHILDREN),
+static WORD_CALCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CALCU_CHILDREN),
     value: None,
 };
 
-static WORD_CALCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CALCU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CALCUA_NODE),
     None,
     None,
@@ -203857,12 +203857,12 @@ static WORD_CALCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CALCUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUT_CHILDREN),
+static WORD_CALCUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -203880,12 +203880,12 @@ pub static WORD_CALCUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_CALCUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUR_CHILDREN),
+static WORD_CALCUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -203901,12 +203901,12 @@ pub static WORD_CALCUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_CALCUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUL_CHILDREN),
+static WORD_CALCUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ador"),
         dictgen::InsensitiveStr::Ascii("aion"),
@@ -203986,23 +203986,23 @@ pub static WORD_CALCUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CALCUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUI_CHILDREN),
+static WORD_CALCUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("m")],
     values: &[&["calcium"]],
     range: 1..=1,
 };
 
-static WORD_CALCUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUA_CHILDREN),
+static WORD_CALCUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("late"),
         dictgen::InsensitiveStr::Ascii("lated"),
@@ -204056,12 +204056,12 @@ pub static WORD_CALCUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CALCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCL_CHILDREN),
+static WORD_CALCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("uate"),
@@ -204093,12 +204093,12 @@ pub static WORD_CALCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CALCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCI_CHILDREN),
+static WORD_CALCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ulate"),
         dictgen::InsensitiveStr::Ascii("ulating"),
@@ -204107,23 +204107,23 @@ pub static WORD_CALCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CALCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCE_CHILDREN),
+static WORD_CALCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["cancel"]],
     range: 1..=1,
 };
 
-static WORD_CALCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCA_CHILDREN),
+static WORD_CALCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("late"),
@@ -204132,12 +204132,12 @@ pub static WORD_CALCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CALB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALB_CHILDREN),
+static WORD_CALB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("irate"),
@@ -204165,12 +204165,12 @@ pub static WORD_CALB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALA_CHILDREN),
+static WORD_CALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("gry"),
@@ -204181,12 +204181,12 @@ pub static WORD_CALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAI_CHILDREN),
+static WORD_CAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lbration"),
         dictgen::InsensitiveStr::Ascii("lbre"),
@@ -204196,12 +204196,12 @@ pub static WORD_CAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_CAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAH_CHILDREN),
+static WORD_CAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -204313,12 +204313,12 @@ pub static WORD_CAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_CAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAF_CHILDREN),
+static WORD_CAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAF_CHILDREN),
     value: Some(&["calf"]),
 };
 
-pub static WORD_CAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -204350,12 +204350,12 @@ pub static WORD_CAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_CAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAE_CHILDREN),
+static WORD_CAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fully"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -204373,23 +204373,23 @@ pub static WORD_CAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAD_CHILDREN),
+static WORD_CAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("idate")],
     values: &[&["candidate"]],
     range: 5..=5,
 };
 
-static WORD_CAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAC_CHILDREN),
+static WORD_CAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahe"),
         dictgen::InsensitiveStr::Ascii("ahes"),
@@ -204497,12 +204497,12 @@ pub static WORD_CAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_CAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAB_CHILDREN),
+static WORD_CAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abge"),
         dictgen::InsensitiveStr::Ascii("abilities"),
@@ -204538,23 +204538,23 @@ pub static WORD_CAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_CAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAA_CHILDREN),
+static WORD_CAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ds")],
     values: &[&["cards"]],
     range: 2..=2,
 };
 
-static WORD_B_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_B_CHILDREN),
+static WORD_B_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_B_CHILDREN),
     value: None,
 };
 
-static WORD_B_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_B_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BA_NODE),
     Some(&WORD_BB_NODE),
     Some(&WORD_BC_NODE),
@@ -204583,23 +204583,23 @@ static WORD_B_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BZ_NODE),
 ];
 
-static WORD_BZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BZ_CHILDREN),
+static WORD_BZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iped")],
     values: &[&["bzipped"]],
     range: 4..=4,
 };
 
-static WORD_BY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BY_CHILDREN),
+static WORD_BY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("cicle"),
@@ -204637,34 +204637,34 @@ pub static WORD_BY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_BW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BW_CHILDREN),
+static WORD_BW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tween")],
     values: &[&["between"]],
     range: 5..=5,
 };
 
-static WORD_BV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BV_CHILDREN),
+static WORD_BV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BV_CHILDREN),
     value: None,
 };
 
-pub static WORD_BV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["be"]],
     range: 1..=1,
 };
 
-static WORD_BU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BU_CHILDREN),
+static WORD_BU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BU_CHILDREN),
     value: None,
 };
 
-static WORD_BU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BUA_NODE),
     Some(&WORD_BUB_NODE),
     None,
@@ -204693,23 +204693,23 @@ static WORD_BU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BUZ_NODE),
 ];
 
-static WORD_BUZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUZ_CHILDREN),
+static WORD_BUZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("illa")],
     values: &[&["bugzilla"]],
     range: 4..=4,
 };
 
-static WORD_BUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUU_CHILDREN),
+static WORD_BUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fers"),
         dictgen::InsensitiveStr::Ascii("ild"),
@@ -204720,12 +204720,12 @@ pub static WORD_BUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUT_CHILDREN),
+static WORD_BUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cherd"),
         dictgen::InsensitiveStr::Ascii("hcered"),
@@ -204795,12 +204795,12 @@ pub static WORD_BUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUS_CHILDREN),
+static WORD_BUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ienss"),
         dictgen::InsensitiveStr::Ascii("inees"),
@@ -204846,12 +204846,12 @@ pub static WORD_BUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUR_CHILDREN),
+static WORD_BUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bon"),
         dictgen::InsensitiveStr::Ascii("eacuracy"),
@@ -204957,23 +204957,23 @@ pub static WORD_BUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_BUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUO_CHILDREN),
+static WORD_BUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ancy")],
     values: &[&["buoyancy"]],
     range: 4..=4,
 };
 
-static WORD_BUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUN_CHILDREN),
+static WORD_BUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bled"),
@@ -205013,12 +205013,12 @@ pub static WORD_BUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_BUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUM_CHILDREN),
+static WORD_BUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("bed"),
@@ -205046,12 +205046,12 @@ pub static WORD_BUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_BUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUL_CHILDREN),
+static WORD_BUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agria"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -205131,12 +205131,12 @@ pub static WORD_BUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_BUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUI_CHILDREN),
+static WORD_BUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUI_CHILDREN),
     value: Some(&["buoy", "buy"]),
 };
 
-pub static WORD_BUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -205246,12 +205246,12 @@ pub static WORD_BUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_BUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUH_CHILDREN),
+static WORD_BUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ddism"),
         dictgen::InsensitiveStr::Ascii("ddist"),
@@ -205261,12 +205261,12 @@ pub static WORD_BUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_BUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUG_CHILDREN),
+static WORD_BUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dets"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -205294,12 +205294,12 @@ pub static WORD_BUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_BUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUF_CHILDREN),
+static WORD_BUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efr"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -205347,12 +205347,12 @@ pub static WORD_BUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUE_CHILDREN),
+static WORD_BUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arucratic"),
         dictgen::InsensitiveStr::Ascii("arucrats"),
@@ -205370,12 +205370,12 @@ pub static WORD_BUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=9,
 };
 
-static WORD_BUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUD_CHILDREN),
+static WORD_BUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("dah"),
@@ -205415,12 +205415,12 @@ pub static WORD_BUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_BUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUB_CHILDREN),
+static WORD_BUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bels"),
         dictgen::InsensitiveStr::Ascii("bless"),
@@ -205430,23 +205430,23 @@ pub static WORD_BUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_BUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUA_CHILDREN),
+static WORD_BUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["baud"]],
     range: 1..=1,
 };
 
-static WORD_BT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BT_CHILDREN),
+static WORD_BT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iched"),
         dictgen::InsensitiveStr::Ascii("iches"),
@@ -205466,12 +205466,12 @@ pub static WORD_BT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_BS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BS_CHILDREN),
+static WORD_BS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aically"),
         dictgen::InsensitiveStr::Ascii("uiness"),
@@ -205480,12 +205480,12 @@ pub static WORD_BS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_BR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BR_CHILDREN),
+static WORD_BR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BR_CHILDREN),
     value: None,
 };
 
-static WORD_BR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BRA_NODE),
     None,
     None,
@@ -205514,12 +205514,12 @@ static WORD_BR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRW_CHILDREN),
+static WORD_BRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("osable"),
         dictgen::InsensitiveStr::Ascii("ose"),
@@ -205539,12 +205539,12 @@ pub static WORD_BRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_BRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRU_CHILDREN),
+static WORD_BRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghtness"),
         dictgen::InsensitiveStr::Ascii("glar"),
@@ -205596,23 +205596,23 @@ pub static WORD_BRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRT_CHILDREN),
+static WORD_BRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ually")],
     values: &[&["brutally"]],
     range: 5..=5,
 };
 
-static WORD_BRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BRO_CHILDREN),
+static WORD_BRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BRO_CHILDREN),
     value: None,
 };
 
-static WORD_BRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BRO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BROA_NODE),
     Some(&WORD_BROB_NODE),
     Some(&WORD_BROC_NODE),
@@ -205641,12 +205641,12 @@ static WORD_BRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BROW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROW_CHILDREN),
+static WORD_BROW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -205686,12 +205686,12 @@ pub static WORD_BROW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_BROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROU_CHILDREN),
+static WORD_BROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gh"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -205700,12 +205700,12 @@ pub static WORD_BROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BROT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROT_CHILDREN),
+static WORD_BROT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("herhod"),
         dictgen::InsensitiveStr::Ascii("herhoood"),
@@ -205721,12 +205721,12 @@ pub static WORD_BROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_BROS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROS_CHILDREN),
+static WORD_BROS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -205758,12 +205758,12 @@ pub static WORD_BROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROO_CHILDREN),
+static WORD_BROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("z"),
         dictgen::InsensitiveStr::Ascii("zes"),
@@ -205772,12 +205772,12 @@ pub static WORD_BROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_BRON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRON_CHILDREN),
+static WORD_BRON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRON_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("coes"),
         dictgen::InsensitiveStr::Ascii("ken"),
@@ -205787,12 +205787,12 @@ pub static WORD_BRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BROK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROK_CHILDREN),
+static WORD_BROK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("em"),
@@ -205810,12 +205810,12 @@ pub static WORD_BROK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BROG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROG_CHILDREN),
+static WORD_BROG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -205824,12 +205824,12 @@ pub static WORD_BROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_BROD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROD_CHILDREN),
+static WORD_BROD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("away"),
         dictgen::InsensitiveStr::Ascii("cast"),
@@ -205839,12 +205839,12 @@ pub static WORD_BROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_BROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROC_CHILDREN),
+static WORD_BROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("her"),
         dictgen::InsensitiveStr::Ascii("ken"),
@@ -205866,23 +205866,23 @@ pub static WORD_BROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_BROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROB_CHILDREN),
+static WORD_BROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lematic")],
     values: &[&["problematic"]],
     range: 7..=7,
 };
 
-static WORD_BROA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROA_CHILDREN),
+static WORD_BROA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cast"),
         dictgen::InsensitiveStr::Ascii("casted"),
@@ -205924,12 +205924,12 @@ pub static WORD_BROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_BRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRN_CHILDREN),
+static WORD_BRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("aches"),
@@ -205938,12 +205938,12 @@ pub static WORD_BRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRI_CHILDREN),
+static WORD_BRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agde"),
         dictgen::InsensitiveStr::Ascii("aner"),
@@ -206069,23 +206069,23 @@ pub static WORD_BRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRF_CHILDREN),
+static WORD_BRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ore")],
     values: &[&["before"]],
     range: 3..=3,
 };
 
-static WORD_BRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRE_CHILDREN),
+static WORD_BRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRE_CHILDREN),
     value: Some(&["be", "brie"]),
 };
 
-pub static WORD_BRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("adcumbs"),
@@ -206197,12 +206197,12 @@ pub static WORD_BRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_BRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BRA_CHILDREN),
+static WORD_BRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BRA_CHILDREN),
     value: None,
 };
 
-static WORD_BRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_BRAB_NODE),
     Some(&WORD_BRAC_NODE),
@@ -206231,12 +206231,12 @@ static WORD_BRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BRAZ_NODE),
 ];
 
-static WORD_BRAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAZ_CHILDREN),
+static WORD_BRAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eer"),
         dictgen::InsensitiveStr::Ascii("ilains"),
@@ -206266,45 +206266,45 @@ pub static WORD_BRAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_BRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAV_CHILDREN),
+static WORD_BRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erly")],
     values: &[&["bravery"]],
     range: 4..=4,
 };
 
-static WORD_BRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAT_CHILDREN),
+static WORD_BRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enders")],
     values: &[&["bartenders"]],
     range: 6..=6,
 };
 
-static WORD_BRAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAS_CHILDREN),
+static WORD_BRAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("illian")],
     values: &[&["brazilian"]],
     range: 6..=6,
 };
 
-static WORD_BRAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAO_CHILDREN),
+static WORD_BRAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dband"),
         dictgen::InsensitiveStr::Ascii("dcast"),
@@ -206330,12 +206330,12 @@ pub static WORD_BRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_BRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAN_CHILDREN),
+static WORD_BRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -206373,23 +206373,23 @@ pub static WORD_BRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAM_CHILDREN),
+static WORD_BRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ches")],
     values: &[&["branches"]],
     range: 4..=4,
 };
 
-static WORD_BRAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAK_CHILDREN),
+static WORD_BRAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edowns"),
         dictgen::InsensitiveStr::Ascii("eout"),
@@ -206413,12 +206413,12 @@ pub static WORD_BRAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_BRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAI_CHILDREN),
+static WORD_BRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nwahsed"),
         dictgen::InsensitiveStr::Ascii("nwahsing"),
@@ -206436,23 +206436,23 @@ pub static WORD_BRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_BRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAE_CHILDREN),
+static WORD_BRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("vry")],
     values: &[&["bravery"]],
     range: 3..=3,
 };
 
-static WORD_BRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAD_CHILDREN),
+static WORD_BRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cast"),
         dictgen::InsensitiveStr::Ascii("frod"),
@@ -206461,12 +206461,12 @@ pub static WORD_BRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_BRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAC_CHILDREN),
+static WORD_BRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eletes"),
         dictgen::InsensitiveStr::Ascii("elettes"),
@@ -206508,23 +206508,23 @@ pub static WORD_BRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_BRAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAB_CHILDREN),
+static WORD_BRAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arian")],
     values: &[&["barbarian"]],
     range: 5..=5,
 };
 
-static WORD_BO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BO_CHILDREN),
+static WORD_BO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BO_CHILDREN),
     value: None,
 };
 
-static WORD_BO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BOA_NODE),
     Some(&WORD_BOB_NODE),
     Some(&WORD_BOC_NODE),
@@ -206553,12 +206553,12 @@ static WORD_BO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOY_CHILDREN),
+static WORD_BOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("cot"),
@@ -206588,12 +206588,12 @@ pub static WORD_BOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOX_CHILDREN),
+static WORD_BOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -206602,12 +206602,12 @@ pub static WORD_BOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=1,
 };
 
-static WORD_BOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOW_CHILDREN),
+static WORD_BOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kay"),
         dictgen::InsensitiveStr::Ascii("kays"),
@@ -206616,12 +206616,12 @@ pub static WORD_BOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_BOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BOU_CHILDREN),
+static WORD_BOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BOU_CHILDREN),
     value: None,
 };
 
-static WORD_BOU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BOU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_BOUC_NODE),
@@ -206650,12 +206650,12 @@ static WORD_BOU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BOUY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUY_CHILDREN),
+static WORD_BOUY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUY_CHILDREN),
     value: Some(&["buoy"]),
 };
 
-pub static WORD_BOUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancy"),
         dictgen::InsensitiveStr::Ascii("ant"),
@@ -206664,12 +206664,12 @@ pub static WORD_BOUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BOUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUU_CHILDREN),
+static WORD_BOUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("nded"),
@@ -206680,12 +206680,12 @@ pub static WORD_BOUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BOUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUT_CHILDREN),
+static WORD_BOUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iqe"),
         dictgen::InsensitiveStr::Ascii("nies"),
@@ -206695,12 +206695,12 @@ pub static WORD_BOUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BOUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUR_CHILDREN),
+static WORD_BOUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egois"),
         dictgen::InsensitiveStr::Ascii("geios"),
@@ -206718,23 +206718,23 @@ pub static WORD_BOUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_BOUQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUQ_CHILDREN),
+static WORD_BOUQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["bouquet"]],
     range: 2..=2,
 };
 
-static WORD_BOUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BOUN_CHILDREN),
+static WORD_BOUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BOUN_CHILDREN),
     value: Some(&["bound"]),
 };
 
-static WORD_BOUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BOUN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BOUNA_NODE),
     Some(&WORD_BOUNB_NODE),
     None,
@@ -206763,12 +206763,12 @@ static WORD_BOUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BOUNU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNU_CHILDREN),
+static WORD_BOUNU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daries"),
         dictgen::InsensitiveStr::Ascii("dary"),
@@ -206778,12 +206778,12 @@ pub static WORD_BOUNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BOUNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNT_CHILDREN),
+static WORD_BOUNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNT_CHILDREN),
     value: Some(&["bound"]),
 };
 
-pub static WORD_BOUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ries"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -206792,12 +206792,12 @@ pub static WORD_BOUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_BOUNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNS_CHILDREN),
+static WORD_BOUNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNS_CHILDREN),
     value: Some(&["bounds"]),
 };
 
-pub static WORD_BOUNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aries"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -206808,12 +206808,12 @@ pub static WORD_BOUNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BOUNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNR_CHILDREN),
+static WORD_BOUNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adies"),
         dictgen::InsensitiveStr::Ascii("ady"),
@@ -206833,12 +206833,12 @@ pub static WORD_BOUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BOUNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNN_CHILDREN),
+static WORD_BOUNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("daries"),
@@ -206858,12 +206858,12 @@ pub static WORD_BOUNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BOUNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNI_CHILDREN),
+static WORD_BOUNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dng"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -206873,12 +206873,12 @@ pub static WORD_BOUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BOUNH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNH_CHILDREN),
+static WORD_BOUNH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daries"),
         dictgen::InsensitiveStr::Ascii("dary"),
@@ -206887,12 +206887,12 @@ pub static WORD_BOUNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_BOUNG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNG_CHILDREN),
+static WORD_BOUNG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aries"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -206903,23 +206903,23 @@ pub static WORD_BOUNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BOUNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNE_CHILDREN),
+static WORD_BOUNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["bounded"]],
     range: 1..=1,
 };
 
-static WORD_BOUND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUND_CHILDREN),
+static WORD_BOUND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUND_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aires"),
         dictgen::InsensitiveStr::Ascii("ares"),
@@ -206959,12 +206959,12 @@ pub static WORD_BOUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_BOUNB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNB_CHILDREN),
+static WORD_BOUNB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daries"),
         dictgen::InsensitiveStr::Ascii("dary"),
@@ -206973,12 +206973,12 @@ pub static WORD_BOUNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_BOUNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNA_CHILDREN),
+static WORD_BOUNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aries"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -207014,23 +207014,23 @@ pub static WORD_BOUNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BOUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUL_CHILDREN),
+static WORD_BOUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dore")],
     values: &[&["boulder"]],
     range: 4..=4,
 };
 
-static WORD_BOUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUI_CHILDREN),
+static WORD_BOUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("nded"),
@@ -207041,12 +207041,12 @@ pub static WORD_BOUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BOUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUD_CHILDREN),
+static WORD_BOUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aries"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -207072,12 +207072,12 @@ pub static WORD_BOUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BOUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUC_CHILDREN),
+static WORD_BOUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -207088,12 +207088,12 @@ pub static WORD_BOUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_BOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOT_CHILDREN),
+static WORD_BOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("hs"),
@@ -207149,12 +207149,12 @@ pub static WORD_BOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOS_CHILDREN),
+static WORD_BOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lter"),
         dictgen::InsensitiveStr::Ascii("tom"),
@@ -207163,12 +207163,12 @@ pub static WORD_BOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_BOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOR_CHILDREN),
+static WORD_BOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aches"),
         dictgen::InsensitiveStr::Ascii("ad"),
@@ -207234,23 +207234,23 @@ pub static WORD_BOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_BOQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOQ_CHILDREN),
+static WORD_BOQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uet")],
     values: &[&["bouquet"]],
     range: 3..=3,
 };
 
-static WORD_BOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BOO_CHILDREN),
+static WORD_BOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BOO_CHILDREN),
     value: None,
 };
 
-static WORD_BOO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BOO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BOOA_NODE),
     None,
     None,
@@ -207279,12 +207279,12 @@ static WORD_BOO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BOOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOU_CHILDREN),
+static WORD_BOOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ndaries"),
@@ -207295,12 +207295,12 @@ pub static WORD_BOOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_BOOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOT_CHILDREN),
+static WORD_BOOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eek"),
         dictgen::InsensitiveStr::Ascii("laoder"),
@@ -207336,12 +207336,12 @@ pub static WORD_BOOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_BOOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOS_CHILDREN),
+static WORD_BOOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("helf"),
         dictgen::InsensitiveStr::Ascii("helves"),
@@ -207363,23 +207363,23 @@ pub static WORD_BOOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_BOOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOR_CHILDREN),
+static WORD_BOOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("jwazee")],
     values: &[&["bourgeoisie"]],
     range: 6..=6,
 };
 
-static WORD_BOOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOO_CHILDREN),
+static WORD_BOOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("k"),
         dictgen::InsensitiveStr::Ascii("lean"),
@@ -207389,12 +207389,12 @@ pub static WORD_BOOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BOOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOM_CHILDREN),
+static WORD_BOOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ark"),
         dictgen::InsensitiveStr::Ascii("arks"),
@@ -207403,12 +207403,12 @@ pub static WORD_BOOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BOOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOL_CHILDREN),
+static WORD_BOOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -207442,12 +207442,12 @@ pub static WORD_BOOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_BOOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOK_CHILDREN),
+static WORD_BOOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amrks"),
         dictgen::InsensitiveStr::Ascii("eeping"),
@@ -207479,12 +207479,12 @@ pub static WORD_BOOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_BOOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOF_CHILDREN),
+static WORD_BOOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -207493,12 +207493,12 @@ pub static WORD_BOOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BOOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOE_CHILDREN),
+static WORD_BOOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOE_CHILDREN),
     value: Some(&["buoy"]),
 };
 
-pub static WORD_BOOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -207514,34 +207514,34 @@ pub static WORD_BOOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_BOOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOD_CHILDREN),
+static WORD_BOOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOD_CHILDREN),
     value: Some(&["boot"]),
 };
 
-pub static WORD_BOOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("a")],
     values: &[&["buddha"]],
     range: 1..=1,
 };
 
-static WORD_BOOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOA_CHILDREN),
+static WORD_BOOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rd")],
     values: &[&["board"]],
     range: 2..=2,
 };
 
-static WORD_BON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BON_CHILDREN),
+static WORD_BON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BON_CHILDREN),
     value: None,
 };
 
-pub static WORD_BON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dary"),
         dictgen::InsensitiveStr::Ascii("nano"),
@@ -207551,12 +207551,12 @@ pub static WORD_BON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_BOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOM_CHILDREN),
+static WORD_BOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bardeada"),
         dictgen::InsensitiveStr::Ascii("bardeado"),
@@ -207576,12 +207576,12 @@ pub static WORD_BOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_BOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOL_CHILDREN),
+static WORD_BOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ean"),
         dictgen::InsensitiveStr::Ascii("een"),
@@ -207599,23 +207599,23 @@ pub static WORD_BOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_BOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOK_CHILDREN),
+static WORD_BOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("marks")],
     values: &[&["bookmarks"]],
     range: 5..=5,
 };
 
-static WORD_BOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOI_CHILDREN),
+static WORD_BOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("des"),
         dictgen::InsensitiveStr::Ascii("erplate"),
@@ -207633,12 +207633,12 @@ pub static WORD_BOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOG_CHILDREN),
+static WORD_BOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anveelia"),
         dictgen::InsensitiveStr::Ascii("anveelias"),
@@ -207656,12 +207656,12 @@ pub static WORD_BOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOF_CHILDREN),
+static WORD_BOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ere"),
         dictgen::InsensitiveStr::Ascii("fer"),
@@ -207672,12 +207672,12 @@ pub static WORD_BOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_BOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOE_CHILDREN),
+static WORD_BOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lean"),
         dictgen::InsensitiveStr::Ascii("leans"),
@@ -207686,12 +207686,12 @@ pub static WORD_BOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_BOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOD_CHILDREN),
+static WORD_BOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dy"),
         dictgen::InsensitiveStr::Ascii("iese"),
@@ -207725,23 +207725,23 @@ pub static WORD_BOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOC_CHILDREN),
+static WORD_BOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ome")],
     values: &[&["become"]],
     range: 3..=3,
 };
 
-static WORD_BOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOB_CHILDREN),
+static WORD_BOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("mers"),
@@ -207751,12 +207751,12 @@ pub static WORD_BOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_BOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOA_CHILDREN),
+static WORD_BOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ds"),
         dictgen::InsensitiveStr::Ascii("rdband"),
@@ -207778,12 +207778,12 @@ pub static WORD_BOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BN_CHILDREN),
+static WORD_BN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("ecause"),
@@ -207793,12 +207793,12 @@ pub static WORD_BN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_BL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BL_CHILDREN),
+static WORD_BL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BL_CHILDREN),
     value: None,
 };
 
-static WORD_BL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BLA_NODE),
     Some(&WORD_BLB_NODE),
     Some(&WORD_BLC_NODE),
@@ -207827,12 +207827,12 @@ static WORD_BL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLU_CHILDREN),
+static WORD_BLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebarries"),
         dictgen::InsensitiveStr::Ascii("eberies"),
@@ -207880,12 +207880,12 @@ pub static WORD_BLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLO_CHILDREN),
+static WORD_BLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -208005,12 +208005,12 @@ pub static WORD_BLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_BLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLI_CHILDREN),
+static WORD_BLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eve"),
         dictgen::InsensitiveStr::Ascii("ndy"),
@@ -208030,12 +208030,12 @@ pub static WORD_BLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_BLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLE_CHILDREN),
+static WORD_BLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ading"),
         dictgen::InsensitiveStr::Ascii("gian"),
@@ -208061,12 +208061,12 @@ pub static WORD_BLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_BLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLC_CHILDREN),
+static WORD_BLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ok"),
         dictgen::InsensitiveStr::Ascii("oks"),
@@ -208075,23 +208075,23 @@ pub static WORD_BLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_BLB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLB_CHILDREN),
+static WORD_BLB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("os")],
     values: &[&["blobs"]],
     range: 2..=2,
 };
 
-static WORD_BLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLA_CHILDREN),
+static WORD_BLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckade"),
         dictgen::InsensitiveStr::Ascii("ckahwks"),
@@ -208189,12 +208189,12 @@ pub static WORD_BLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_BJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BJ_CHILDREN),
+static WORD_BJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -208203,12 +208203,12 @@ pub static WORD_BJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_BI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BI_CHILDREN),
+static WORD_BI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BI_CHILDREN),
     value: None,
 };
 
-static WORD_BI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BIA_NODE),
     Some(&WORD_BIB_NODE),
     Some(&WORD_BIC_NODE),
@@ -208237,12 +208237,12 @@ static WORD_BI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BIZ_NODE),
 ];
 
-static WORD_BIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIZ_CHILDREN),
+static WORD_BIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("arely"),
@@ -208260,12 +208260,12 @@ pub static WORD_BIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_BIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIY_CHILDREN),
+static WORD_BIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ou"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -208274,12 +208274,12 @@ pub static WORD_BIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_BIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIV_CHILDREN),
+static WORD_BIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ouaced"),
         dictgen::InsensitiveStr::Ascii("ouacing"),
@@ -208289,23 +208289,23 @@ pub static WORD_BIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_BIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIU_CHILDREN),
+static WORD_BIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lt")],
     values: &[&["built", "build"]],
     range: 2..=2,
 };
 
-static WORD_BIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIT_CHILDREN),
+static WORD_BIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amps"),
         dictgen::InsensitiveStr::Ascii("ap"),
@@ -208367,12 +208367,12 @@ pub static WORD_BIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIS_CHILDREN),
+static WORD_BIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cut"),
@@ -208406,12 +208406,12 @@ pub static WORD_BIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIR_CHILDREN),
+static WORD_BIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("damn"),
         dictgen::InsensitiveStr::Ascii("dges"),
@@ -208459,23 +208459,23 @@ pub static WORD_BIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_BIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIP_CHILDREN),
+static WORD_BIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("loar")],
     values: &[&["bipolar"]],
     range: 4..=4,
 };
 
-static WORD_BIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIO_CHILDREN),
+static WORD_BIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gted"),
         dictgen::InsensitiveStr::Ascii("gtry"),
@@ -208503,12 +208503,12 @@ pub static WORD_BIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_BIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIN_CHILDREN),
+static WORD_BIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("airy"),
         dictgen::InsensitiveStr::Ascii("anary"),
@@ -208536,12 +208536,12 @@ pub static WORD_BIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIM_CHILDREN),
+static WORD_BIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ask"),
         dictgen::InsensitiveStr::Ascii("illenia"),
@@ -208559,12 +208559,12 @@ pub static WORD_BIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIL_CHILDREN),
+static WORD_BIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angual"),
         dictgen::InsensitiveStr::Ascii("ateraly"),
@@ -208614,34 +208614,34 @@ pub static WORD_BIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_BIJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIJ_CHILDREN),
+static WORD_BIJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cetive")],
     values: &[&["bijective"]],
     range: 6..=6,
 };
 
-static WORD_BII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BII_CHILDREN),
+static WORD_BII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BII_CHILDREN),
     value: None,
 };
 
-pub static WORD_BII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nary")],
     values: &[&["binary"]],
     range: 4..=4,
 };
 
-static WORD_BIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIG_CHILDREN),
+static WORD_BIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("allic"),
         dictgen::InsensitiveStr::Ascii("egr"),
@@ -208671,23 +208671,23 @@ pub static WORD_BIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIF_CHILDREN),
+static WORD_BIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("goot")],
     values: &[&["bigfoot"]],
     range: 4..=4,
 };
 
-static WORD_BIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIE_CHILDREN),
+static WORD_BIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("jing"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -208696,12 +208696,12 @@ pub static WORD_BIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_BID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BID_CHILDREN),
+static WORD_BID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BID_CHILDREN),
     value: None,
 };
 
-pub static WORD_BID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dings"),
         dictgen::InsensitiveStr::Ascii("imentionnal"),
@@ -208721,12 +208721,12 @@ pub static WORD_BID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_BIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIC_CHILDREN),
+static WORD_BIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("thes"),
@@ -208736,23 +208736,23 @@ pub static WORD_BIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIB_CHILDREN),
+static WORD_BIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ilcal")],
     values: &[&["biblical"]],
     range: 5..=5,
 };
 
-static WORD_BIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIA_CHILDREN),
+static WORD_BIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nries"),
         dictgen::InsensitiveStr::Ascii("nry"),
@@ -208762,34 +208762,34 @@ pub static WORD_BIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_BG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BG_CHILDREN),
+static WORD_BG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inning")],
     values: &[&["beginning"]],
     range: 6..=6,
 };
 
-static WORD_BF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BF_CHILDREN),
+static WORD_BF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fer")],
     values: &[&["buffer"]],
     range: 3..=3,
 };
 
-static WORD_BE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BE_CHILDREN),
+static WORD_BE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BE_CHILDREN),
     value: None,
 };
 
-static WORD_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BEA_NODE),
     Some(&WORD_BEB_NODE),
     Some(&WORD_BEC_NODE),
@@ -208818,12 +208818,12 @@ static WORD_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEY_CHILDREN),
+static WORD_BEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oncye"),
         dictgen::InsensitiveStr::Ascii("one"),
@@ -208834,12 +208834,12 @@ pub static WORD_BEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEW_CHILDREN),
+static WORD_BEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eeen"),
         dictgen::InsensitiveStr::Ascii("een"),
@@ -208850,12 +208850,12 @@ pub static WORD_BEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_BEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEV_CHILDREN),
+static WORD_BEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cause"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -208873,12 +208873,12 @@ pub static WORD_BEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEU_CHILDREN),
+static WORD_BEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atiful"),
         dictgen::InsensitiveStr::Ascii("atifully"),
@@ -208910,12 +208910,12 @@ pub static WORD_BEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_BET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BET_CHILDREN),
+static WORD_BET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BET_CHILDREN),
     value: None,
 };
 
-pub static WORD_BET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ales"),
         dictgen::InsensitiveStr::Ascii("cause"),
@@ -208995,12 +208995,12 @@ pub static WORD_BET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BES_CHILDREN),
+static WORD_BES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BES_CHILDREN),
     value: None,
 };
 
-pub static WORD_BES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cribed"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -209030,12 +209030,12 @@ pub static WORD_BES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BER_CHILDREN),
+static WORD_BER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BER_CHILDREN),
     value: None,
 };
 
-pub static WORD_BER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aded"),
         dictgen::InsensitiveStr::Ascii("ekley"),
@@ -209069,12 +209069,12 @@ pub static WORD_BER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_BEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEO_CHILDREN),
+static WORD_BEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fre"),
         dictgen::InsensitiveStr::Ascii("nd"),
@@ -209084,12 +209084,12 @@ pub static WORD_BEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_BEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BEN_CHILDREN),
+static WORD_BEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BEN_CHILDREN),
     value: None,
 };
 
-static WORD_BEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BENA_NODE),
     None,
     Some(&WORD_BENC_NODE),
@@ -209118,34 +209118,34 @@ static WORD_BEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENO_CHILDREN),
+static WORD_BENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("velent")],
     values: &[&["benevolent"]],
     range: 6..=6,
 };
 
-static WORD_BENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENN_CHILDREN),
+static WORD_BENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENN_CHILDREN),
     value: Some(&["been"]),
 };
 
-pub static WORD_BENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_BENJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENJ_CHILDREN),
+static WORD_BENJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENJ_CHILDREN),
     value: Some(&["binge"]),
 };
 
-pub static WORD_BENJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -209156,12 +209156,12 @@ pub static WORD_BENJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENI_CHILDREN),
+static WORD_BENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dect"),
         dictgen::InsensitiveStr::Ascii("fical"),
@@ -209189,12 +209189,12 @@ pub static WORD_BENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BENH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENH_CHILDREN),
+static WORD_BENH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gazi"),
         dictgen::InsensitiveStr::Ascii("ind"),
@@ -209203,12 +209203,12 @@ pub static WORD_BENH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BENG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENG_CHILDREN),
+static WORD_BENG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENG_CHILDREN),
     value: Some(&["being"]),
 };
 
-pub static WORD_BENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahzi"),
         dictgen::InsensitiveStr::Ascii("alas"),
@@ -209246,12 +209246,12 @@ pub static WORD_BENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENF_CHILDREN),
+static WORD_BENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icial"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -209261,12 +209261,12 @@ pub static WORD_BENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENE_CHILDREN),
+static WORD_BENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chmark"),
         dictgen::InsensitiveStr::Ascii("chmarked"),
@@ -209328,12 +209328,12 @@ pub static WORD_BENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_BENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENC_CHILDREN),
+static WORD_BENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hamarked"),
         dictgen::InsensitiveStr::Ascii("hamarking"),
@@ -209383,34 +209383,34 @@ pub static WORD_BENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_BENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENA_CHILDREN),
+static WORD_BENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gls")],
     values: &[&["bengals"]],
     range: 3..=3,
 };
 
-static WORD_BEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEM_CHILDREN),
+static WORD_BEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("usemnt")],
     values: &[&["bemusement"]],
     range: 6..=6,
 };
 
-static WORD_BEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BEL_CHILDREN),
+static WORD_BEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BEL_CHILDREN),
     value: None,
 };
 
-static WORD_BEL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BEL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -209439,12 +209439,12 @@ static WORD_BEL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BELY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELY_CHILDREN),
+static WORD_BELY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -209462,34 +209462,34 @@ pub static WORD_BELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_BELW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELW_CHILDREN),
+static WORD_BELW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("o")],
     values: &[&["below"]],
     range: 1..=1,
 };
 
-static WORD_BELS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELS_CHILDREN),
+static WORD_BELS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sings")],
     values: &[&["blessings"]],
     range: 5..=5,
 };
 
-static WORD_BELO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELO_CHILDREN),
+static WORD_BELO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("ging"),
@@ -209513,12 +209513,12 @@ pub static WORD_BELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BELL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELL_CHILDREN),
+static WORD_BELL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igerant"),
         dictgen::InsensitiveStr::Ascii("igerante"),
@@ -209536,12 +209536,12 @@ pub static WORD_BELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_BELI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELI_CHILDREN),
+static WORD_BELI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avable"),
         dictgen::InsensitiveStr::Ascii("ebable"),
@@ -209609,12 +209609,12 @@ pub static WORD_BELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_BELG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELG_CHILDREN),
+static WORD_BELG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("uim"),
@@ -209623,12 +209623,12 @@ pub static WORD_BELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_BELE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELE_CHILDREN),
+static WORD_BELE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agured"),
         dictgen::InsensitiveStr::Ascii("ave"),
@@ -209680,23 +209680,23 @@ pub static WORD_BELE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_BELD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELD_CHILDREN),
+static WORD_BELD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELD_CHILDREN),
     value: Some(&["held"]),
 };
 
-pub static WORD_BELD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_BEJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEJ_CHILDREN),
+static WORD_BEJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iing"),
         dictgen::InsensitiveStr::Ascii("ond"),
@@ -209705,12 +209705,12 @@ pub static WORD_BEJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_BEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEI_CHILDREN),
+static WORD_BEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eve"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -209734,12 +209734,12 @@ pub static WORD_BEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_BEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEH_CHILDREN),
+static WORD_BEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abior"),
         dictgen::InsensitiveStr::Ascii("abiors"),
@@ -209835,12 +209835,12 @@ pub static WORD_BEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEG_CHILDREN),
+static WORD_BEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -209926,12 +209926,12 @@ pub static WORD_BEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEF_CHILDREN),
+static WORD_BEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fer"),
         dictgen::InsensitiveStr::Ascii("ire"),
@@ -209971,12 +209971,12 @@ pub static WORD_BEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEE_CHILDREN),
+static WORD_BEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("en"),
@@ -210004,12 +210004,12 @@ pub static WORD_BEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_BED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BED_CHILDREN),
+static WORD_BED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BED_CHILDREN),
     value: None,
 };
 
-pub static WORD_BED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -210018,12 +210018,12 @@ pub static WORD_BED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=3,
 };
 
-static WORD_BEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEC_CHILDREN),
+static WORD_BEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aause"),
         dictgen::InsensitiveStr::Ascii("acdd"),
@@ -210131,12 +210131,12 @@ pub static WORD_BEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEB_CHILDREN),
+static WORD_BEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efore"),
         dictgen::InsensitiveStr::Ascii("ongs"),
@@ -210146,12 +210146,12 @@ pub static WORD_BEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEA_CHILDREN),
+static WORD_BEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caon"),
         dictgen::InsensitiveStr::Ascii("cause"),
@@ -210259,12 +210259,12 @@ pub static WORD_BEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_BC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BC_CHILDREN),
+static WORD_BC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("ause"),
@@ -210286,12 +210286,12 @@ pub static WORD_BC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_BB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BB_CHILDREN),
+static WORD_BB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efore"),
         dictgen::InsensitiveStr::Ascii("oolean"),
@@ -210301,12 +210301,12 @@ pub static WORD_BB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_BA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BA_CHILDREN),
+static WORD_BA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BA_CHILDREN),
     value: Some(&["by", "be"]),
 };
 
-static WORD_BA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BAA_NODE),
     Some(&WORD_BAB_NODE),
     Some(&WORD_BAC_NODE),
@@ -210335,12 +210335,12 @@ static WORD_BA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BAZ_NODE),
 ];
 
-static WORD_BAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAZ_CHILDREN),
+static WORD_BAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("erk"),
@@ -210349,12 +210349,12 @@ pub static WORD_BAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=3,
 };
 
-static WORD_BAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAY_CHILDREN),
+static WORD_BAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blon"),
         dictgen::InsensitiveStr::Ascii("ge"),
@@ -210374,23 +210374,23 @@ pub static WORD_BAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAU_CHILDREN),
+static WORD_BAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ght")],
     values: &[&["bought"]],
     range: 3..=3,
 };
 
-static WORD_BAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAT_CHILDREN),
+static WORD_BAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chleur"),
         dictgen::InsensitiveStr::Ascii("chleurs"),
@@ -210468,12 +210468,12 @@ pub static WORD_BAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAS_CHILDREN),
+static WORD_BAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ci"),
         dictgen::InsensitiveStr::Ascii("cially"),
@@ -210561,12 +210561,12 @@ pub static WORD_BAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_BAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAR_CHILDREN),
+static WORD_BAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abrian"),
         dictgen::InsensitiveStr::Ascii("abrians"),
@@ -210674,12 +210674,12 @@ pub static WORD_BAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAP_CHILDREN),
+static WORD_BAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tims"),
         dictgen::InsensitiveStr::Ascii("tisim"),
@@ -210689,12 +210689,12 @@ pub static WORD_BAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_BAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAO_CHILDREN),
+static WORD_BAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rdwalk"),
@@ -210705,12 +210705,12 @@ pub static WORD_BAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAN_CHILDREN),
+static WORD_BAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("annas"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -210788,12 +210788,12 @@ pub static WORD_BAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAL_CHILDREN),
+static WORD_BAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acing"),
         dictgen::InsensitiveStr::Ascii("anceada"),
@@ -210865,12 +210865,12 @@ pub static WORD_BAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAK_CHILDREN),
+static WORD_BAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cers"),
@@ -210902,12 +210902,12 @@ pub static WORD_BAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_BAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAI_CHILDREN),
+static WORD_BAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sc"),
         dictgen::InsensitiveStr::Ascii("scly"),
@@ -210918,12 +210918,12 @@ pub static WORD_BAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_BAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAH_CHILDREN),
+static WORD_BAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aving"),
         dictgen::InsensitiveStr::Ascii("avior"),
@@ -210941,12 +210941,12 @@ pub static WORD_BAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_BAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAG_CHILDREN),
+static WORD_BAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -210955,34 +210955,34 @@ pub static WORD_BAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_BAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAF_CHILDREN),
+static WORD_BAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ore")],
     values: &[&["before"]],
     range: 3..=3,
 };
 
-static WORD_BAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAE_CHILDREN),
+static WORD_BAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["based"]],
     range: 1..=1,
 };
 
-static WORD_BAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAD_CHILDREN),
+static WORD_BAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mitten"),
         dictgen::InsensitiveStr::Ascii("nits"),
@@ -210993,12 +210993,12 @@ pub static WORD_BAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_BAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BAC_CHILDREN),
+static WORD_BAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BAC_CHILDREN),
     value: None,
 };
 
-static WORD_BAC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BAC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BACA_NODE),
     None,
     None,
@@ -211027,12 +211027,12 @@ static WORD_BAC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BACW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACW_CHILDREN),
+static WORD_BACW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -211041,12 +211041,12 @@ pub static WORD_BACW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BACU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACU_CHILDREN),
+static WORD_BACU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -211055,12 +211055,12 @@ pub static WORD_BACU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_BACT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACT_CHILDREN),
+static WORD_BACT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("racking"),
@@ -211069,23 +211069,23 @@ pub static WORD_BACT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_BACL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACL_CHILDREN),
+static WORD_BACL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACL_CHILDREN),
     value: Some(&["back"]),
 };
 
-pub static WORD_BACL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ony")],
     values: &[&["balcony"]],
     range: 3..=3,
 };
 
-static WORD_BACK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BACK_CHILDREN),
+static WORD_BACK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BACK_CHILDREN),
     value: None,
 };
 
-static WORD_BACK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BACK_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BACKA_NODE),
     Some(&WORD_BACKB_NODE),
     None,
@@ -211114,12 +211114,12 @@ static WORD_BACK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BACKW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKW_CHILDREN),
+static WORD_BACKW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("ardss"),
@@ -211141,23 +211141,23 @@ pub static WORD_BACKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BACKT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKT_CHILDREN),
+static WORD_BACKT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("acking")],
     values: &[&["backpacking"]],
     range: 6..=6,
 };
 
-static WORD_BACKS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKS_CHILDREN),
+static WORD_BACKS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apce"),
         dictgen::InsensitiveStr::Ascii("lah"),
@@ -211179,12 +211179,12 @@ pub static WORD_BACKS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BACKR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKR_CHILDREN),
+static WORD_BACKR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("efence"),
@@ -211206,12 +211206,12 @@ pub static WORD_BACKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_BACKP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKP_CHILDREN),
+static WORD_BACKP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKP_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acing"),
         dictgen::InsensitiveStr::Ascii("ackng"),
@@ -211231,12 +211231,12 @@ pub static WORD_BACKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_BACKO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKO_CHILDREN),
+static WORD_BACKO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("und"),
@@ -211246,12 +211246,12 @@ pub static WORD_BACKO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_BACKN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKN_CHILDREN),
+static WORD_BACKN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eds"),
@@ -211260,12 +211260,12 @@ pub static WORD_BACKN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BACKL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKL_CHILDREN),
+static WORD_BACKL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ght"),
         dictgen::InsensitiveStr::Ascii("ghting"),
@@ -211275,34 +211275,34 @@ pub static WORD_BACKL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_BACKJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKJ_CHILDREN),
+static WORD_BACKJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("acking")],
     values: &[&["backpacking"]],
     range: 6..=6,
 };
 
-static WORD_BACKH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKH_CHILDREN),
+static WORD_BACKH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("acking")],
     values: &[&["backpacking"]],
     range: 6..=6,
 };
 
-static WORD_BACKG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKG_CHILDREN),
+static WORD_BACKG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orund"),
         dictgen::InsensitiveStr::Ascii("orunds"),
@@ -211362,12 +211362,12 @@ pub static WORD_BACKG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_BACKF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKF_CHILDREN),
+static WORD_BACKF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eild"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -211383,12 +211383,12 @@ pub static WORD_BACKF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_BACKE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKE_CHILDREN),
+static WORD_BACKE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("dn"),
@@ -211412,12 +211412,12 @@ pub static WORD_BACKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_BACKD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKD_CHILDREN),
+static WORD_BACKD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ooor"),
         dictgen::InsensitiveStr::Ascii("or"),
@@ -211426,12 +211426,12 @@ pub static WORD_BACKD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_BACKB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKB_CHILDREN),
+static WORD_BACKB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acking"),
         dictgen::InsensitiveStr::Ascii("round"),
@@ -211441,12 +211441,12 @@ pub static WORD_BACKB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_BACKA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKA_CHILDREN),
+static WORD_BACKA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("loriette"),
         dictgen::InsensitiveStr::Ascii("loriettes"),
@@ -211456,34 +211456,34 @@ pub static WORD_BACKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_BACJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACJ_CHILDREN),
+static WORD_BACJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("kward")],
     values: &[&["backward"]],
     range: 5..=5,
 };
 
-static WORD_BACI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACI_CHILDREN),
+static WORD_BACI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("c")],
     values: &[&["basic"]],
     range: 1..=1,
 };
 
-static WORD_BACH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACH_CHILDREN),
+static WORD_BACH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elores"),
         dictgen::InsensitiveStr::Ascii("elour"),
@@ -211507,23 +211507,23 @@ pub static WORD_BACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_BACG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACG_CHILDREN),
+static WORD_BACG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("round")],
     values: &[&["background"]],
     range: 5..=5,
 };
 
-static WORD_BACE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACE_CHILDREN),
+static WORD_BACE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ause"),
         dictgen::InsensitiveStr::Ascii("hlor"),
@@ -211533,23 +211533,23 @@ pub static WORD_BACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_BACA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACA_CHILDREN),
+static WORD_BACA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("use")],
     values: &[&["because"]],
     range: 3..=3,
 };
 
-static WORD_BAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAB_CHILDREN),
+static WORD_BAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("lyon"),
@@ -211573,23 +211573,23 @@ pub static WORD_BAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAA_CHILDREN),
+static WORD_BAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("se")],
     values: &[&["abase", "base"]],
     range: 2..=2,
 };
 
-static WORD_A_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_A_CHILDREN),
+static WORD_A_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_A_CHILDREN),
     value: None,
 };
 
-static WORD_A_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_A_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AA_NODE),
     Some(&WORD_AB_NODE),
     Some(&WORD_AC_NODE),
@@ -211618,12 +211618,12 @@ static WORD_A_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_AZ_NODE),
 ];
 
-static WORD_AZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AZ_CHILDREN),
+static WORD_AZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_AZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ma"),
         dictgen::InsensitiveStr::Ascii("mith"),
@@ -211633,12 +211633,12 @@ pub static WORD_AZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_AY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AY_CHILDREN),
+static WORD_AY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AY_CHILDREN),
     value: None,
 };
 
-pub static WORD_AY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nchronous"),
         dictgen::InsensitiveStr::Ascii("snc"),
@@ -211656,12 +211656,12 @@ pub static WORD_AY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_AX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AX_CHILDREN),
+static WORD_AX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AX_CHILDREN),
     value: None,
 };
 
-pub static WORD_AX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ises"),
         dictgen::InsensitiveStr::Ascii("issymmetric"),
@@ -211679,12 +211679,12 @@ pub static WORD_AX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_AW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AW_CHILDREN),
+static WORD_AW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AW_CHILDREN),
     value: None,
 };
 
-pub static WORD_AW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailable"),
         dictgen::InsensitiveStr::Ascii("akend"),
@@ -211766,12 +211766,12 @@ pub static WORD_AW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_AV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AV_CHILDREN),
+static WORD_AV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AV_CHILDREN),
     value: None,
 };
 
-static WORD_AV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AVA_NODE),
     None,
     Some(&WORD_AVC_NODE),
@@ -211800,12 +211800,12 @@ static WORD_AV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AVT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVT_CHILDREN),
+static WORD_AVT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aars"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -211815,12 +211815,12 @@ pub static WORD_AVT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_AVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVR_CHILDREN),
+static WORD_AVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iables"),
@@ -211831,12 +211831,12 @@ pub static WORD_AVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_AVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVO_CHILDREN),
+static WORD_AVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -211874,23 +211874,23 @@ pub static WORD_AVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_AVN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVN_CHILDREN),
+static WORD_AVN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("egers")],
     values: &[&["avengers"]],
     range: 5..=5,
 };
 
-static WORD_AVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVI_CHILDREN),
+static WORD_AVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("aiton"),
@@ -211930,23 +211930,23 @@ pub static WORD_AVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_AVG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVG_CHILDREN),
+static WORD_AVG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erage")],
     values: &[&["average"]],
     range: 5..=5,
 };
 
-static WORD_AVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVE_CHILDREN),
+static WORD_AVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ngence"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -211982,12 +211982,12 @@ pub static WORD_AVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_AVD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVD_CHILDREN),
+static WORD_AVD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVD_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isories"),
         dictgen::InsensitiveStr::Ascii("isoriy"),
@@ -212003,12 +212003,12 @@ pub static WORD_AVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_AVC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVC_CHILDREN),
+static WORD_AVC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oid"),
         dictgen::InsensitiveStr::Ascii("oids"),
@@ -212017,12 +212017,12 @@ pub static WORD_AVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_AVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AVA_CHILDREN),
+static WORD_AVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AVA_CHILDREN),
     value: None,
 };
 
-static WORD_AVA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AVA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_AVAC_NODE),
@@ -212051,12 +212051,12 @@ static WORD_AVA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AVAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAT_CHILDREN),
+static WORD_AVAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aras"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -212074,12 +212074,12 @@ pub static WORD_AVAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_AVAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAR_CHILDREN),
+static WORD_AVAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ageing"),
@@ -212097,12 +212097,12 @@ pub static WORD_AVAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_AVAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAO_CHILDREN),
+static WORD_AVAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("id"),
         dictgen::InsensitiveStr::Ascii("idable"),
@@ -212112,12 +212112,12 @@ pub static WORD_AVAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_AVAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAN_CHILDREN),
+static WORD_AVAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -212128,12 +212128,12 @@ pub static WORD_AVAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_AVAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAL_CHILDREN),
+static WORD_AVAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -212171,12 +212171,12 @@ pub static WORD_AVAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_AVAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AVAI_CHILDREN),
+static WORD_AVAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AVAI_CHILDREN),
     value: None,
 };
 
-static WORD_AVAI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AVAI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AVAIA_NODE),
     Some(&WORD_AVAIB_NODE),
     None,
@@ -212205,23 +212205,23 @@ static WORD_AVAI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AVAIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAIT_CHILDREN),
+static WORD_AVAIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ion")],
     values: &[&["aviation"]],
     range: 3..=3,
 };
 
-static WORD_AVAIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAIL_CHILDREN),
+static WORD_AVAIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aable"),
         dictgen::InsensitiveStr::Ascii("abable"),
@@ -212345,12 +212345,12 @@ pub static WORD_AVAIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_AVAII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAII_CHILDREN),
+static WORD_AVAII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAII_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -212368,12 +212368,12 @@ pub static WORD_AVAII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_AVAIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAIB_CHILDREN),
+static WORD_AVAIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("ility"),
@@ -212389,12 +212389,12 @@ pub static WORD_AVAIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_AVAIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAIA_CHILDREN),
+static WORD_AVAIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -212418,12 +212418,12 @@ pub static WORD_AVAIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_AVAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAC_CHILDREN),
+static WORD_AVAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ado"),
         dictgen::InsensitiveStr::Ascii("ados"),
@@ -212433,12 +212433,12 @@ pub static WORD_AVAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_AU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AU_CHILDREN),
+static WORD_AU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AU_CHILDREN),
     value: None,
 };
 
-static WORD_AU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_AUC_NODE),
@@ -212467,12 +212467,12 @@ static WORD_AU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUX_CHILDREN),
+static WORD_AUX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUX_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialiary"),
         dictgen::InsensitiveStr::Ascii("ilaries"),
@@ -212510,12 +212510,12 @@ pub static WORD_AUX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_AUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUT_CHILDREN),
+static WORD_AUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUT_CHILDREN),
     value: None,
 };
 
-static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AUTA_NODE),
     None,
     Some(&WORD_AUTC_NODE),
@@ -212544,45 +212544,45 @@ static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTU_CHILDREN),
+static WORD_AUTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("m")],
     values: &[&["autumn"]],
     range: 1..=1,
 };
 
-static WORD_AUTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTT_CHILDREN),
+static WORD_AUTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oatack")],
     values: &[&["autoattack"]],
     range: 6..=6,
 };
 
-static WORD_AUTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTS_CHILDREN),
+static WORD_AUTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itic")],
     values: &[&["autistic"]],
     range: 4..=4,
 };
 
-static WORD_AUTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUTO_CHILDREN),
+static WORD_AUTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUTO_CHILDREN),
     value: None,
 };
 
-static WORD_AUTO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUTO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AUTOA_NODE),
     None,
     Some(&WORD_AUTOC_NODE),
@@ -212611,12 +212611,12 @@ static WORD_AUTO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOT_CHILDREN),
+static WORD_AUTOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orium"),
         dictgen::InsensitiveStr::Ascii("oriums"),
@@ -212625,12 +212625,12 @@ pub static WORD_AUTOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_AUTOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOS_CHILDREN),
+static WORD_AUTOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("avegs"),
@@ -212646,12 +212646,12 @@ pub static WORD_AUTOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_AUTOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOR_CHILDREN),
+static WORD_AUTOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOR_CHILDREN),
     value: Some(&["author"]),
 };
 
-pub static WORD_AUTOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ealease"),
         dictgen::InsensitiveStr::Ascii("isation"),
@@ -212675,34 +212675,34 @@ pub static WORD_AUTOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_AUTOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOP_CHILDREN),
+static WORD_AUTOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sec")],
     values: &[&["autospec"]],
     range: 3..=3,
 };
 
-static WORD_AUTOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOO_CHILDREN),
+static WORD_AUTOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nf")],
     values: &[&["autoconf"]],
     range: 2..=2,
 };
 
-static WORD_AUTON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTON_CHILDREN),
+static WORD_AUTON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTON_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agotiation"),
         dictgen::InsensitiveStr::Ascii("amous"),
@@ -212822,12 +212822,12 @@ pub static WORD_AUTON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=18,
 };
 
-static WORD_AUTOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOM_CHILDREN),
+static WORD_AUTOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aatically"),
         dictgen::InsensitiveStr::Ascii("actically"),
@@ -212951,34 +212951,34 @@ pub static WORD_AUTOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_AUTOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOL_CHILDREN),
+static WORD_AUTOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aod")],
     values: &[&["autoload"]],
     range: 3..=3,
 };
 
-static WORD_AUTOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOK_CHILDREN),
+static WORD_AUTOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orrect")],
     values: &[&["autocorrect"]],
     range: 6..=6,
 };
 
-static WORD_AUTOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOI_CHILDREN),
+static WORD_AUTOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncrememnt"),
         dictgen::InsensitiveStr::Ascii("ncrementive"),
@@ -212988,23 +212988,23 @@ pub static WORD_AUTOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=11,
 };
 
-static WORD_AUTOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOH_CHILDREN),
+static WORD_AUTOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orized")],
     values: &[&["authorized"]],
     range: 6..=6,
 };
 
-static WORD_AUTOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOG_CHILDREN),
+static WORD_AUTOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enrated"),
         dictgen::InsensitiveStr::Ascii("enratet"),
@@ -213026,12 +213026,12 @@ pub static WORD_AUTOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_AUTOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOF_CHILDREN),
+static WORD_AUTOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilt"),
         dictgen::InsensitiveStr::Ascii("omat"),
@@ -213041,23 +213041,23 @@ pub static WORD_AUTOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_AUTOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOE_CHILDREN),
+static WORD_AUTOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("select")],
     values: &[&["autoselect"]],
     range: 6..=6,
 };
 
-static WORD_AUTOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOD_CHILDREN),
+static WORD_AUTOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("ection"),
@@ -213066,12 +213066,12 @@ pub static WORD_AUTOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_AUTOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOC_CHILDREN),
+static WORD_AUTOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("htonous"),
         dictgen::InsensitiveStr::Ascii("mplete"),
@@ -213125,12 +213125,12 @@ pub static WORD_AUTOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_AUTOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOA_CHILDREN),
+static WORD_AUTOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gressive"),
         dictgen::InsensitiveStr::Ascii("mtically"),
@@ -213150,12 +213150,12 @@ pub static WORD_AUTOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_AUTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTM_CHILDREN),
+static WORD_AUTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atic"),
         dictgen::InsensitiveStr::Ascii("atically"),
@@ -213171,12 +213171,12 @@ pub static WORD_AUTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_AUTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTI_CHILDREN),
+static WORD_AUTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("magically"),
         dictgen::InsensitiveStr::Ascii("matic"),
@@ -213198,12 +213198,12 @@ pub static WORD_AUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_AUTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUTH_CHILDREN),
+static WORD_AUTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUTH_CHILDREN),
     value: None,
 };
 
-static WORD_AUTH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUTH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -213232,23 +213232,23 @@ static WORD_AUTH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHU_CHILDREN),
+static WORD_AUTHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["author"]],
     range: 1..=1,
 };
 
-static WORD_AUTHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHR_CHILDREN),
+static WORD_AUTHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oity"),
         dictgen::InsensitiveStr::Ascii("oization"),
@@ -213274,12 +213274,12 @@ pub static WORD_AUTHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_AUTHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHO_CHILDREN),
+static WORD_AUTHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biographic"),
         dictgen::InsensitiveStr::Ascii("biography"),
@@ -213345,12 +213345,12 @@ pub static WORD_AUTHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_AUTHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUTHE_CHILDREN),
+static WORD_AUTHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUTHE_CHILDREN),
     value: None,
 };
 
-static WORD_AUTHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUTHE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_AUTHEC_NODE),
@@ -213379,12 +213379,12 @@ static WORD_AUTHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTHET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHET_CHILDREN),
+static WORD_AUTHET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHET_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("henticate"),
         dictgen::InsensitiveStr::Ascii("henticated"),
@@ -213462,12 +213462,12 @@ pub static WORD_AUTHET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=11,
 };
 
-static WORD_AUTHER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHER_CHILDREN),
+static WORD_AUTHER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHER_CHILDREN),
     value: Some(&["author"]),
 };
 
-pub static WORD_AUTHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isation"),
         dictgen::InsensitiveStr::Ascii("ise"),
@@ -213487,12 +213487,12 @@ pub static WORD_AUTHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_AUTHEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUTHEN_CHILDREN),
+static WORD_AUTHEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUTHEN_CHILDREN),
     value: None,
 };
 
-static WORD_AUTHEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUTHEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AUTHENA_NODE),
     None,
     Some(&WORD_AUTHENC_NODE),
@@ -213521,12 +213521,12 @@ static WORD_AUTHEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTHENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENT_CHILDREN),
+static WORD_AUTHENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -213584,12 +213584,12 @@ pub static WORD_AUTHENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=9,
 };
 
-static WORD_AUTHENR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENR_CHILDREN),
+static WORD_AUTHENR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icate"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -213611,12 +213611,12 @@ pub static WORD_AUTHENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=7,
 };
 
-static WORD_AUTHENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENI_CHILDREN),
+static WORD_AUTHENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cae"),
         dictgen::InsensitiveStr::Ascii("caed"),
@@ -213694,12 +213694,12 @@ pub static WORD_AUTHENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=8,
 };
 
-static WORD_AUTHENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENF_CHILDREN),
+static WORD_AUTHENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -213721,12 +213721,12 @@ pub static WORD_AUTHENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_AUTHENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENE_CHILDREN),
+static WORD_AUTHENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nticate"),
         dictgen::InsensitiveStr::Ascii("nticated"),
@@ -213748,12 +213748,12 @@ pub static WORD_AUTHENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 7..=9,
 };
 
-static WORD_AUTHEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHEND_CHILDREN),
+static WORD_AUTHEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icate"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -213775,12 +213775,12 @@ pub static WORD_AUTHEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=7,
 };
 
-static WORD_AUTHENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENC_CHILDREN),
+static WORD_AUTHENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -213846,12 +213846,12 @@ pub static WORD_AUTHENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=8,
 };
 
-static WORD_AUTHENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENA_CHILDREN),
+static WORD_AUTHENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ticate"),
         dictgen::InsensitiveStr::Ascii("ticated"),
@@ -213873,12 +213873,12 @@ pub static WORD_AUTHENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 6..=8,
 };
 
-static WORD_AUTHEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHEC_CHILDREN),
+static WORD_AUTHEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -213900,12 +213900,12 @@ pub static WORD_AUTHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_AUTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTE_CHILDREN),
+static WORD_AUTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nticate"),
         dictgen::InsensitiveStr::Ascii("nticated"),
@@ -213929,23 +213929,23 @@ pub static WORD_AUTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=10,
 };
 
-static WORD_AUTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTC_CHILDREN),
+static WORD_AUTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("omplete")],
     values: &[&["autocomplete"]],
     range: 7..=7,
 };
 
-static WORD_AUTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTA_CHILDREN),
+static WORD_AUTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("save"),
         dictgen::InsensitiveStr::Ascii("saves"),
@@ -213954,12 +213954,12 @@ pub static WORD_AUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_AUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUS_CHILDREN),
+static WORD_AUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sian"),
         dictgen::InsensitiveStr::Ascii("tair"),
@@ -214027,23 +214027,23 @@ pub static WORD_AUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_AUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUR_CHILDREN),
+static WORD_AUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("omated")],
     values: &[&["automated"]],
     range: 6..=6,
 };
 
-static WORD_AUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUO_CHILDREN),
+static WORD_AUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("spacing"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -214063,12 +214063,12 @@ pub static WORD_AUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_AUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUN_CHILDREN),
+static WORD_AUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thenticate"),
         dictgen::InsensitiveStr::Ascii("thenticated"),
@@ -214090,12 +214090,12 @@ pub static WORD_AUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 10..=12,
 };
 
-static WORD_AUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUI_CHILDREN),
+static WORD_AUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dobook"),
         dictgen::InsensitiveStr::Ascii("dobooks"),
@@ -214104,12 +214104,12 @@ pub static WORD_AUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_AUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUH_CHILDREN),
+static WORD_AUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tenticate"),
         dictgen::InsensitiveStr::Ascii("tentication"),
@@ -214125,12 +214125,12 @@ pub static WORD_AUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_AUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUG_CHILDREN),
+static WORD_AUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("mnet"),
@@ -214162,23 +214162,23 @@ pub static WORD_AUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_AUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUF_CHILDREN),
+static WORD_AUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["after"]],
     range: 3..=3,
 };
 
-static WORD_AUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUD_CHILDREN),
+static WORD_AUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actiy"),
         dictgen::InsensitiveStr::Ascii("bile"),
@@ -214218,12 +214218,12 @@ pub static WORD_AUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_AUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUC_CHILDREN),
+static WORD_AUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cess"),
         dictgen::InsensitiveStr::Ascii("cessive"),
@@ -214241,12 +214241,12 @@ pub static WORD_AUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_AT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AT_CHILDREN),
+static WORD_AT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AT_CHILDREN),
     value: None,
 };
 
-static WORD_AT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ATA_NODE),
     None,
     Some(&WORD_ATC_NODE),
@@ -214275,12 +214275,12 @@ static WORD_AT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATU_CHILDREN),
+static WORD_ATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("henticate"),
         dictgen::InsensitiveStr::Ascii("henticated"),
@@ -214302,12 +214302,12 @@ pub static WORD_ATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=11,
 };
 
-static WORD_ATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ATT_CHILDREN),
+static WORD_ATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ATT_CHILDREN),
     value: None,
 };
 
-static WORD_ATT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ATT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ATTA_NODE),
     None,
     Some(&WORD_ATTC_NODE),
@@ -214336,12 +214336,12 @@ static WORD_ATT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ATTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTT_CHILDREN),
+static WORD_ATTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ached"),
         dictgen::InsensitiveStr::Ascii("ack"),
@@ -214359,12 +214359,12 @@ pub static WORD_ATTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ATTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ATTR_CHILDREN),
+static WORD_ATTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ATTR_CHILDREN),
     value: None,
 };
 
-static WORD_ATTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ATTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ATTRA_NODE),
     Some(&WORD_ATTRB_NODE),
     None,
@@ -214393,12 +214393,12 @@ static WORD_ATTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ATTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRU_CHILDREN),
+static WORD_ATTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bite"),
         dictgen::InsensitiveStr::Ascii("bites"),
@@ -214430,12 +214430,12 @@ pub static WORD_ATTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ATTRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRR_CHILDREN),
+static WORD_ATTRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibute"),
         dictgen::InsensitiveStr::Ascii("ibuted"),
@@ -214451,23 +214451,23 @@ pub static WORD_ATTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ATTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRO_CHILDREN),
+static WORD_ATTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cities")],
     values: &[&["atrocities"]],
     range: 6..=6,
 };
 
-static WORD_ATTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRI_CHILDREN),
+static WORD_ATTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bbute"),
         dictgen::InsensitiveStr::Ascii("biute"),
@@ -214587,12 +214587,12 @@ pub static WORD_ATTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ATTRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRB_CHILDREN),
+static WORD_ATTRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iute"),
         dictgen::InsensitiveStr::Ascii("ute"),
@@ -214612,12 +214612,12 @@ pub static WORD_ATTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ATTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRA_CHILDREN),
+static WORD_ATTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cs"),
         dictgen::InsensitiveStr::Ascii("cters"),
@@ -214643,12 +214643,12 @@ pub static WORD_ATTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ATTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTO_CHILDREN),
+static WORD_ATTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rnies"),
         dictgen::InsensitiveStr::Ascii("sencond"),
@@ -214658,23 +214658,23 @@ pub static WORD_ATTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ATTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTN_CHILDREN),
+static WORD_ATTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etion")],
     values: &[&["attention"]],
     range: 5..=5,
 };
 
-static WORD_ATTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTM_CHILDREN),
+static WORD_ATTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ept"),
         dictgen::InsensitiveStr::Ascii("epted"),
@@ -214692,12 +214692,12 @@ pub static WORD_ATTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ATTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTI_CHILDREN),
+static WORD_ATTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bures"),
         dictgen::InsensitiveStr::Ascii("bute"),
@@ -214731,12 +214731,12 @@ pub static WORD_ATTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ATTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTE_CHILDREN),
+static WORD_ATTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ched"),
         dictgen::InsensitiveStr::Ascii("ment"),
@@ -214830,12 +214830,12 @@ pub static WORD_ATTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ATTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTC_CHILDREN),
+static WORD_ATTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahed"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -214855,12 +214855,12 @@ pub static WORD_ATTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ATTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTA_CHILDREN),
+static WORD_ATTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ached"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -214944,12 +214944,12 @@ pub static WORD_ATTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATR_CHILDREN),
+static WORD_ATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("active"),
@@ -214999,23 +214999,23 @@ pub static WORD_ATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ATQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATQ_CHILDREN),
+static WORD_ATQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uired")],
     values: &[&["acquired"]],
     range: 5..=5,
 };
 
-static WORD_ATO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATO_CHILDREN),
+static WORD_ATO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matically"),
         dictgen::InsensitiveStr::Ascii("mical"),
@@ -215053,12 +215053,12 @@ pub static WORD_ATO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ATM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATM_CHILDREN),
+static WORD_ATM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oic"),
         dictgen::InsensitiveStr::Ascii("oically"),
@@ -215090,12 +215090,12 @@ pub static WORD_ATM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ATL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATL_CHILDREN),
+static WORD_ATL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antc"),
         dictgen::InsensitiveStr::Ascii("antia"),
@@ -215113,12 +215113,12 @@ pub static WORD_ATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATI_CHILDREN),
+static WORD_ATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("facts"),
         dictgen::InsensitiveStr::Ascii("ttude"),
@@ -215134,12 +215134,12 @@ pub static WORD_ATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ATH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATH_CHILDREN),
+static WORD_ATH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eisim"),
         dictgen::InsensitiveStr::Ascii("eistc"),
@@ -215221,12 +215221,12 @@ pub static WORD_ATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATE_CHILDREN),
+static WORD_ATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("last"),
         dictgen::InsensitiveStr::Ascii("mpt"),
@@ -215260,23 +215260,23 @@ pub static WORD_ATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATC_CHILDREN),
+static WORD_ATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ualy")],
     values: &[&["actually"]],
     range: 4..=4,
 };
 
-static WORD_ATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATA_CHILDREN),
+static WORD_ATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -215314,12 +215314,12 @@ pub static WORD_ATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_AS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AS_CHILDREN),
+static WORD_AS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AS_CHILDREN),
     value: None,
 };
 
-static WORD_AS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASA_NODE),
     Some(&WORD_ASB_NODE),
     Some(&WORD_ASC_NODE),
@@ -215348,12 +215348,12 @@ static WORD_AS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ASY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASY_CHILDREN),
+static WORD_ASY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chronize"),
         dictgen::InsensitiveStr::Ascii("chronized"),
@@ -215443,12 +215443,12 @@ pub static WORD_ASY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_ASW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASW_CHILDREN),
+static WORD_ASW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -215457,12 +215457,12 @@ pub static WORD_ASW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_ASU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASU_CHILDREN),
+static WORD_ASU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("do"),
         dictgen::InsensitiveStr::Ascii("me"),
@@ -215494,12 +215494,12 @@ pub static WORD_ASU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_AST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AST_CHILDREN),
+static WORD_AST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AST_CHILDREN),
     value: None,
 };
 
-pub static WORD_AST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arisk"),
         dictgen::InsensitiveStr::Ascii("arisks"),
@@ -215611,12 +215611,12 @@ pub static WORD_AST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ASS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ASS_CHILDREN),
+static WORD_ASS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ASS_CHILDREN),
     value: None,
 };
 
-static WORD_ASS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ASS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASSA_NODE),
     None,
     Some(&WORD_ASSC_NODE),
@@ -215645,12 +215645,12 @@ static WORD_ASS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ASSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSY_CHILDREN),
+static WORD_ASSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("metric"),
         dictgen::InsensitiveStr::Ascii("metrical"),
@@ -215692,12 +215692,12 @@ pub static WORD_ASSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ASSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSU_CHILDREN),
+static WORD_ASSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alt"),
         dictgen::InsensitiveStr::Ascii("alted"),
@@ -215819,12 +215819,12 @@ pub static WORD_ASSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_ASSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSS_CHILDREN),
+static WORD_ASSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asin"),
         dictgen::InsensitiveStr::Ascii("asins"),
@@ -215868,12 +215868,12 @@ pub static WORD_ASSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ASSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ASSO_CHILDREN),
+static WORD_ASSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ASSO_CHILDREN),
     value: None,
 };
 
-static WORD_ASSO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ASSO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASSOA_NODE),
     None,
     Some(&WORD_ASSOC_NODE),
@@ -215902,12 +215902,12 @@ static WORD_ASSO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASSOZ_NODE),
 ];
 
-static WORD_ASSOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOZ_CHILDREN),
+static WORD_ASSOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iated"),
         dictgen::InsensitiveStr::Ascii("iation"),
@@ -215916,12 +215916,12 @@ pub static WORD_ASSOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_ASSOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOT_CHILDREN),
+static WORD_ASSOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iated"),
         dictgen::InsensitiveStr::Ascii("iation"),
@@ -215931,12 +215931,12 @@ pub static WORD_ASSOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ASSOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOS_CHILDREN),
+static WORD_ASSOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciate"),
         dictgen::InsensitiveStr::Ascii("ciated"),
@@ -215974,23 +215974,23 @@ pub static WORD_ASSOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_ASSOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOM_CHILDREN),
+static WORD_ASSOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ption")],
     values: &[&["assumption"]],
     range: 5..=5,
 };
 
-static WORD_ASSOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOI_CHILDREN),
+static WORD_ASSOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("cate"),
@@ -216014,12 +216014,12 @@ pub static WORD_ASSOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ASSOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOC_CHILDREN),
+static WORD_ASSOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aited"),
         dictgen::InsensitiveStr::Ascii("aites"),
@@ -216129,12 +216129,12 @@ pub static WORD_ASSOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ASSOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOA_CHILDREN),
+static WORD_ASSOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -216156,23 +216156,23 @@ pub static WORD_ASSOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ASSN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSN_CHILDREN),
+static WORD_ASSN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["assange"]],
     range: 3..=3,
 };
 
-static WORD_ASSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSM_CHILDREN),
+static WORD_ASSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("bler"),
@@ -216214,12 +216214,12 @@ pub static WORD_ASSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_ASSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ASSI_CHILDREN),
+static WORD_ASSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ASSI_CHILDREN),
     value: None,
 };
 
-static WORD_ASSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ASSI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASSIA_NODE),
     None,
     Some(&WORD_ASSIC_NODE),
@@ -216248,12 +216248,12 @@ static WORD_ASSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ASSIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIT_CHILDREN),
+static WORD_ASSIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIT_CHILDREN),
     value: Some(&["assist"]),
 };
 
-pub static WORD_ASSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ant"),
@@ -216271,12 +216271,12 @@ pub static WORD_ASSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ASSIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIS_CHILDREN),
+static WORD_ASSIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ant"),
@@ -216328,12 +216328,12 @@ pub static WORD_ASSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ASSIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIO_CHILDREN),
+static WORD_ASSIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -216361,12 +216361,12 @@ pub static WORD_ASSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ASSIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIN_CHILDREN),
+static WORD_ASSIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -216396,12 +216396,12 @@ pub static WORD_ASSIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ASSIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIM_CHILDREN),
+static WORD_ASSIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -216437,12 +216437,12 @@ pub static WORD_ASSIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ASSIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIH_CHILDREN),
+static WORD_ASSIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nment"),
         dictgen::InsensitiveStr::Ascii("nments"),
@@ -216451,12 +216451,12 @@ pub static WORD_ASSIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_ASSIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIG_CHILDREN),
+static WORD_ASSIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("end"),
@@ -216544,23 +216544,23 @@ pub static WORD_ASSIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ASSID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSID_CHILDREN),
+static WORD_ASSID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSID_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["aside"]],
     range: 1..=1,
 };
 
-static WORD_ASSIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIC_CHILDREN),
+static WORD_ASSIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -216592,23 +216592,23 @@ pub static WORD_ASSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ASSIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIA_CHILDREN),
+static WORD_ASSIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tnce")],
     values: &[&["assistance"]],
     range: 4..=4,
 };
 
-static WORD_ASSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSH_CHILDREN),
+static WORD_ASSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("atts"),
@@ -216617,12 +216617,12 @@ pub static WORD_ASSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ASSG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSG_CHILDREN),
+static WORD_ASSG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -216642,12 +216642,12 @@ pub static WORD_ASSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ASSF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSF_CHILDREN),
+static WORD_ASSF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alt"),
         dictgen::InsensitiveStr::Ascii("alted"),
@@ -216658,12 +216658,12 @@ pub static WORD_ASSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ASSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSE_CHILDREN),
+static WORD_ASSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bly"),
         dictgen::InsensitiveStr::Ascii("bmly"),
@@ -216767,12 +216767,12 @@ pub static WORD_ASSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_ASSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSC_CHILDREN),
+static WORD_ASSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciated"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -216792,12 +216792,12 @@ pub static WORD_ASSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ASSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSA_CHILDREN),
+static WORD_ASSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gne"),
         dictgen::InsensitiveStr::Ascii("mble"),
@@ -216857,23 +216857,23 @@ pub static WORD_ASSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ASR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASR_CHILDREN),
+static WORD_ASR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onist")],
     values: &[&["arsonist"]],
     range: 5..=5,
 };
 
-static WORD_ASP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASP_CHILDREN),
+static WORD_ASP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahlt"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -216905,12 +216905,12 @@ pub static WORD_ASP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ASO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASO_CHILDREN),
+static WORD_ASO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASO_CHILDREN),
     value: Some(&["also"]),
 };
 
-pub static WORD_ASO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciated"),
         dictgen::InsensitiveStr::Ascii("lute"),
@@ -216920,12 +216920,12 @@ pub static WORD_ASO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ASN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASN_CHILDREN),
+static WORD_ASN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("wer"),
@@ -216951,12 +216951,12 @@ pub static WORD_ASN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ASL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASL_CHILDREN),
+static WORD_ASL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ias"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -216965,12 +216965,12 @@ pub static WORD_ASL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_ASK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASK_CHILDREN),
+static WORD_ASK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -216981,12 +216981,12 @@ pub static WORD_ASK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ASI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASI_CHILDREN),
+static WORD_ASI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("gned"),
@@ -217034,23 +217034,23 @@ pub static WORD_ASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ASH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASH_CHILDREN),
+static WORD_ASH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("palt")],
     values: &[&["asphalt"]],
     range: 4..=4,
 };
 
-static WORD_ASE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASE_CHILDREN),
+static WORD_ASE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mble"),
         dictgen::InsensitiveStr::Ascii("mbled"),
@@ -217120,12 +217120,12 @@ pub static WORD_ASE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_ASD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASD_CHILDREN),
+static WORD_ASD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ignment"),
         dictgen::InsensitiveStr::Ascii("ignments"),
@@ -217134,12 +217134,12 @@ pub static WORD_ASD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_ASC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASC_CHILDREN),
+static WORD_ASC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("conciated"),
         dictgen::InsensitiveStr::Ascii("eding"),
@@ -217165,12 +217165,12 @@ pub static WORD_ASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ASB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASB_CHILDREN),
+static WORD_ASB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("estoast"),
         dictgen::InsensitiveStr::Ascii("estoes"),
@@ -217216,12 +217216,12 @@ pub static WORD_ASB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_ASA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASA_CHILDREN),
+static WORD_ASA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -217231,12 +217231,12 @@ pub static WORD_ASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_AR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AR_CHILDREN),
+static WORD_AR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AR_CHILDREN),
     value: None,
 };
 
-static WORD_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARA_NODE),
     Some(&WORD_ARB_NODE),
     Some(&WORD_ARC_NODE),
@@ -217265,23 +217265,23 @@ static WORD_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARV_CHILDREN),
+static WORD_ARV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["argv"]],
     range: 1..=1,
 };
 
-static WORD_ARU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARU_CHILDREN),
+static WORD_ARU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gable"),
         dictgen::InsensitiveStr::Ascii("gably"),
@@ -217309,12 +217309,12 @@ pub static WORD_ARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_ART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ART_CHILDREN),
+static WORD_ART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ART_CHILDREN),
     value: None,
 };
 
-pub static WORD_ART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cile"),
         dictgen::InsensitiveStr::Ascii("cle"),
@@ -217436,12 +217436,12 @@ pub static WORD_ART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARS_CHILDREN),
+static WORD_ARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enaal"),
         dictgen::InsensitiveStr::Ascii("neal"),
@@ -217451,12 +217451,12 @@ pub static WORD_ARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARR_CHILDREN),
+static WORD_ARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARR_CHILDREN),
     value: None,
 };
 
-static WORD_ARR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARRA_NODE),
     None,
     None,
@@ -217485,12 +217485,12 @@ static WORD_ARR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRY_CHILDREN),
+static WORD_ARRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRY_CHILDREN),
     value: Some(&["array", "carry"]),
 };
 
-pub static WORD_ARRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("as"),
@@ -217500,23 +217500,23 @@ pub static WORD_ARRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_ARRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRT_CHILDREN),
+static WORD_ARRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ibute")],
     values: &[&["attribute"]],
     range: 5..=5,
 };
 
-static WORD_ARRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRR_CHILDREN),
+static WORD_ARRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -217534,12 +217534,12 @@ pub static WORD_ARRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ARRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRO_CHILDREN),
+static WORD_ARRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRO_CHILDREN),
     value: Some(&["arrow"]),
 };
 
-pub static WORD_ARRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("und"),
@@ -217548,23 +217548,23 @@ pub static WORD_ARRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_ARRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRN_CHILDREN),
+static WORD_ARRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["arrange"]],
     range: 3..=3,
 };
 
-static WORD_ARRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRI_CHILDREN),
+static WORD_ARRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -217582,12 +217582,12 @@ pub static WORD_ARRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ARRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRE_CHILDREN),
+static WORD_ARRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRE_CHILDREN),
     value: Some(&["are"]),
 };
 
-pub static WORD_ARRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("nged"),
@@ -217609,12 +217609,12 @@ pub static WORD_ARRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ARRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRA_CHILDREN),
+static WORD_ARRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ge"),
@@ -217732,12 +217732,12 @@ pub static WORD_ARRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ARQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARQ_CHILDREN),
+static WORD_ARQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uitecture"),
         dictgen::InsensitiveStr::Ascii("uitectures"),
@@ -217746,12 +217746,12 @@ pub static WORD_ARQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=10,
 };
 
-static WORD_ARP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARP_CHILDREN),
+static WORD_ARP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anoid"),
         dictgen::InsensitiveStr::Ascii("atheid"),
@@ -217761,12 +217761,12 @@ pub static WORD_ARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_ARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARO_CHILDREN),
+static WORD_ARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ara"),
         dictgen::InsensitiveStr::Ascii("aras"),
@@ -217800,12 +217800,12 @@ pub static WORD_ARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARM_CHILDREN),
+static WORD_ARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agaddon"),
         dictgen::InsensitiveStr::Ascii("ageddan"),
@@ -217865,12 +217865,12 @@ pub static WORD_ARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARL_CHILDREN),
+static WORD_ARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eady"),
         dictgen::InsensitiveStr::Ascii("ighty"),
@@ -217888,23 +217888,23 @@ pub static WORD_ARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ARK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARK_CHILDREN),
+static WORD_ARK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("asnas")],
     values: &[&["arkansas"]],
     range: 5..=5,
 };
 
-static WORD_ARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARI_CHILDREN),
+static WORD_ARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bitary"),
         dictgen::InsensitiveStr::Ascii("biter"),
@@ -217998,12 +217998,12 @@ pub static WORD_ARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ARH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARH_CHILDREN),
+static WORD_ARH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ive"),
         dictgen::InsensitiveStr::Ascii("ives"),
@@ -218013,12 +218013,12 @@ pub static WORD_ARH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_ARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARG_CHILDREN),
+static WORD_ARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ements"),
@@ -218146,12 +218146,12 @@ pub static WORD_ARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARE_CHILDREN),
+static WORD_ARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ady"),
         dictgen::InsensitiveStr::Ascii("aldy"),
@@ -218179,12 +218179,12 @@ pub static WORD_ARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARD_CHILDREN),
+static WORD_ARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iuno"),
         dictgen::InsensitiveStr::Ascii("vark"),
@@ -218194,12 +218194,12 @@ pub static WORD_ARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_ARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARC_CHILDREN),
+static WORD_ARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARC_CHILDREN),
     value: None,
 };
 
-static WORD_ARC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARCA_NODE),
     None,
     None,
@@ -218228,45 +218228,45 @@ static WORD_ARC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARCY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCY_CHILDREN),
+static WORD_ARCY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lic")],
     values: &[&["acrylic"]],
     range: 3..=3,
 };
 
-static WORD_ARCV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCV_CHILDREN),
+static WORD_ARCV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hive")],
     values: &[&["archive"]],
     range: 4..=4,
 };
 
-static WORD_ARCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCT_CHILDREN),
+static WORD_ARCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icle")],
     values: &[&["article"]],
     range: 4..=4,
 };
 
-static WORD_ARCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCI_CHILDREN),
+static WORD_ARCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("techture"),
         dictgen::InsensitiveStr::Ascii("tecture"),
@@ -218290,12 +218290,12 @@ pub static WORD_ARCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ARCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARCH_CHILDREN),
+static WORD_ARCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARCH_CHILDREN),
     value: None,
 };
 
-static WORD_ARCH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARCH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARCHA_NODE),
     None,
     None,
@@ -218324,23 +218324,23 @@ static WORD_ARCH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARCHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHY_CHILDREN),
+static WORD_ARCHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("types")],
     values: &[&["archetypes"]],
     range: 5..=5,
 };
 
-static WORD_ARCHV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHV_CHILDREN),
+static WORD_ARCHV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ie"),
@@ -218351,12 +218351,12 @@ pub static WORD_ARCHV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_ARCHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHT_CHILDREN),
+static WORD_ARCHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecture"),
         dictgen::InsensitiveStr::Ascii("ectures"),
@@ -218382,12 +218382,12 @@ pub static WORD_ARCHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ARCHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHO_CHILDREN),
+static WORD_ARCHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ve"),
@@ -218396,12 +218396,12 @@ pub static WORD_ARCHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_ARCHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHI_CHILDREN),
+static WORD_ARCHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ac"),
         dictgen::InsensitiveStr::Ascii("ctect"),
@@ -218517,12 +218517,12 @@ pub static WORD_ARCHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_ARCHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHE_CHILDREN),
+static WORD_ARCHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aologist"),
         dictgen::InsensitiveStr::Ascii("aologists"),
@@ -218560,12 +218560,12 @@ pub static WORD_ARCHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_ARCHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHA_CHILDREN),
+static WORD_ARCHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elogical"),
         dictgen::InsensitiveStr::Ascii("elogists"),
@@ -218587,12 +218587,12 @@ pub static WORD_ARCHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ARCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCE_CHILDREN),
+static WORD_ARCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("htype"),
         dictgen::InsensitiveStr::Ascii("htypes"),
@@ -218601,12 +218601,12 @@ pub static WORD_ARCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_ARCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCA_CHILDREN),
+static WORD_ARCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heology"),
         dictgen::InsensitiveStr::Ascii("hic"),
@@ -218615,12 +218615,12 @@ pub static WORD_ARCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ARB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARB_CHILDREN),
+static WORD_ARB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARB_CHILDREN),
     value: None,
 };
 
-static WORD_ARB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARBA_NODE),
     None,
     None,
@@ -218649,12 +218649,12 @@ static WORD_ARB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARBU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBU_CHILDREN),
+static WORD_ARBU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("trarily"),
         dictgen::InsensitiveStr::Ascii("trary"),
@@ -218663,12 +218663,12 @@ pub static WORD_ARBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ARBT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBT_CHILDREN),
+static WORD_ARBT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irarily"),
         dictgen::InsensitiveStr::Ascii("irary"),
@@ -218684,12 +218684,12 @@ pub static WORD_ARBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ARBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBR_CHILDREN),
+static WORD_ARBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itarily"),
         dictgen::InsensitiveStr::Ascii("itary"),
@@ -218709,12 +218709,12 @@ pub static WORD_ARBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ARBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBO_CHILDREN),
+static WORD_ARBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rt"),
         dictgen::InsensitiveStr::Ascii("rted"),
@@ -218725,12 +218725,12 @@ pub static WORD_ARBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ARBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARBI_CHILDREN),
+static WORD_ARBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARBI_CHILDREN),
     value: None,
 };
 
-static WORD_ARBI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARBI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARBIA_NODE),
     Some(&WORD_ARBIB_NODE),
     None,
@@ -218759,12 +218759,12 @@ static WORD_ARBI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARBIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBIT_CHILDREN),
+static WORD_ARBIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arary"),
         dictgen::InsensitiveStr::Ascii("arily"),
@@ -218894,12 +218894,12 @@ pub static WORD_ARBIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ARBIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBIR_CHILDREN),
+static WORD_ARBIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arily"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -218923,12 +218923,12 @@ pub static WORD_ARBIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ARBII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBII_CHILDREN),
+static WORD_ARBII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBII_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("trarily"),
         dictgen::InsensitiveStr::Ascii("trary"),
@@ -218937,12 +218937,12 @@ pub static WORD_ARBII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ARBIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBIB_CHILDREN),
+static WORD_ARBIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tarily"),
         dictgen::InsensitiveStr::Ascii("tary"),
@@ -218958,12 +218958,12 @@ pub static WORD_ARBIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ARBIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBIA_CHILDREN),
+static WORD_ARBIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("traily"),
         dictgen::InsensitiveStr::Ascii("tray"),
@@ -218972,23 +218972,23 @@ pub static WORD_ARBIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ARBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBA_CHILDREN),
+static WORD_ARBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("trary")],
     values: &[&["arbitrary"]],
     range: 5..=5,
 };
 
-static WORD_ARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARA_CHILDREN),
+static WORD_ARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cnid"),
         dictgen::InsensitiveStr::Ascii("cnids"),
@@ -219018,12 +219018,12 @@ pub static WORD_ARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_AQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AQ_CHILDREN),
+static WORD_AQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_AQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("aurium"),
@@ -219105,12 +219105,12 @@ pub static WORD_AQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_AP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AP_CHILDREN),
+static WORD_AP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AP_CHILDREN),
     value: None,
 };
 
-static WORD_AP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APA_NODE),
     None,
     None,
@@ -219139,12 +219139,12 @@ static WORD_AP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APY_CHILDREN),
+static WORD_APY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APY_CHILDREN),
     value: None,
 };
 
-pub static WORD_APY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oon"),
         dictgen::InsensitiveStr::Ascii("ooned"),
@@ -219155,23 +219155,23 @@ pub static WORD_APY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_APT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APT_CHILDREN),
+static WORD_APT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APT_CHILDREN),
     value: None,
 };
 
-pub static WORD_APT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itudine")],
     values: &[&["aptitude"]],
     range: 7..=7,
 };
 
-static WORD_APS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APS_CHILDREN),
+static WORD_APS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APS_CHILDREN),
     value: None,
 };
 
-pub static WORD_APS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aragus"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -219195,12 +219195,12 @@ pub static WORD_APS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_APR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APR_CHILDREN),
+static WORD_APR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APR_CHILDREN),
     value: None,
 };
 
-pub static WORD_APR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atheid"),
         dictgen::InsensitiveStr::Ascii("eciate"),
@@ -219312,12 +219312,12 @@ pub static WORD_APR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_APP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_APP_CHILDREN),
+static WORD_APP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_APP_CHILDREN),
     value: None,
 };
 
-static WORD_APP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_APP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APPA_NODE),
     None,
     None,
@@ -219346,23 +219346,23 @@ static WORD_APP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPY_CHILDREN),
+static WORD_APPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPY_CHILDREN),
     value: Some(&["apply"]),
 };
 
-pub static WORD_APPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["applying"]],
     range: 3..=3,
 };
 
-static WORD_APPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_APPR_CHILDREN),
+static WORD_APPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_APPR_CHILDREN),
     value: None,
 };
 
-static WORD_APPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_APPR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APPRA_NODE),
     None,
     Some(&WORD_APPRC_NODE),
@@ -219391,12 +219391,12 @@ static WORD_APPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APPRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRP_CHILDREN),
+static WORD_APPRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("riate"),
         dictgen::InsensitiveStr::Ascii("riately"),
@@ -219405,12 +219405,12 @@ pub static WORD_APPRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_APPRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_APPRO_CHILDREN),
+static WORD_APPRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_APPRO_CHILDREN),
     value: None,
 };
 
-static WORD_APPRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_APPRO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APPROA_NODE),
     Some(&WORD_APPROB_NODE),
     Some(&WORD_APPROC_NODE),
@@ -219439,12 +219439,12 @@ static WORD_APPRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APPROX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROX_CHILDREN),
+static WORD_APPROX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROX_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amate"),
         dictgen::InsensitiveStr::Ascii("amately"),
@@ -219518,12 +219518,12 @@ pub static WORD_APPROX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=9,
 };
 
-static WORD_APPROV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROV_CHILDREN),
+static WORD_APPROV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROV_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("ement"),
@@ -219532,12 +219532,12 @@ pub static WORD_APPROV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_APPROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROU_CHILDREN),
+static WORD_APPROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("val"),
         dictgen::InsensitiveStr::Ascii("ve"),
@@ -219555,23 +219555,23 @@ pub static WORD_APPROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_APPROS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROS_CHILDREN),
+static WORD_APPROS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROS_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("traphe")],
     values: &[&["apostrophe"]],
     range: 6..=6,
 };
 
-static WORD_APPROR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROR_CHILDREN),
+static WORD_APPROR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROR_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iately"),
@@ -219589,12 +219589,12 @@ pub static WORD_APPROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_APPROP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROP_CHILDREN),
+static WORD_APPROP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROP_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aite"),
         dictgen::InsensitiveStr::Ascii("eriate"),
@@ -219686,12 +219686,12 @@ pub static WORD_APPROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_APPROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROO_CHILDREN),
+static WORD_APPROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("priate"),
         dictgen::InsensitiveStr::Ascii("ximate"),
@@ -219711,23 +219711,23 @@ pub static WORD_APPROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=9,
 };
 
-static WORD_APPROM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROM_CHILDREN),
+static WORD_APPROM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROM_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ixation")],
     values: &[&["approximation"]],
     range: 7..=7,
 };
 
-static WORD_APPROI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROI_CHILDREN),
+static WORD_APPROI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROI_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("mation"),
@@ -219736,12 +219736,12 @@ pub static WORD_APPROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_APPROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROC_CHILDREN),
+static WORD_APPROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROC_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("he"),
@@ -219759,23 +219759,23 @@ pub static WORD_APPROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_APPROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROB_CHILDREN),
+static WORD_APPROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROB_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iate")],
     values: &[&["appropriate"]],
     range: 4..=4,
 };
 
-static WORD_APPROA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROA_CHILDREN),
+static WORD_APPROA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chs"),
         dictgen::InsensitiveStr::Ascii("cing"),
@@ -219785,12 +219785,12 @@ pub static WORD_APPROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_APPRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRI_CHILDREN),
+static WORD_APPRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -219862,12 +219862,12 @@ pub static WORD_APPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_APPRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRE_CHILDREN),
+static WORD_APPRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aciate"),
         dictgen::InsensitiveStr::Ascii("aciated"),
@@ -219975,12 +219975,12 @@ pub static WORD_APPRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_APPRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRC_CHILDREN),
+static WORD_APPRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -219989,12 +219989,12 @@ pub static WORD_APPRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_APPRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRA_CHILDREN),
+static WORD_APPRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ently"),
@@ -220018,12 +220018,12 @@ pub static WORD_APPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_APPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPP_CHILDREN),
+static WORD_APPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ear"),
         dictgen::InsensitiveStr::Ascii("ears"),
@@ -220053,12 +220053,12 @@ pub static WORD_APPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_APPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPO_CHILDREN),
+static WORD_APPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inment"),
         dictgen::InsensitiveStr::Ascii("intement"),
@@ -220166,23 +220166,23 @@ pub static WORD_APPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_APPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPN_CHILDREN),
+static WORD_APPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["append"]],
     range: 2..=2,
 };
 
-static WORD_APPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_APPL_CHILDREN),
+static WORD_APPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_APPL_CHILDREN),
     value: None,
 };
 
-static WORD_APPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_APPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APPLA_NODE),
     None,
     Some(&WORD_APPLC_NODE),
@@ -220211,12 +220211,12 @@ static WORD_APPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APPLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLY_CHILDREN),
+static WORD_APPLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("cable"),
@@ -220240,12 +220240,12 @@ pub static WORD_APPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_APPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLU_CHILDREN),
+static WORD_APPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("ase"),
@@ -220254,12 +220254,12 @@ pub static WORD_APPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_APPLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLO_CHILDREN),
+static WORD_APPLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gies"),
         dictgen::InsensitiveStr::Ascii("gize"),
@@ -220268,12 +220268,12 @@ pub static WORD_APPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_APPLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLL_CHILDREN),
+static WORD_APPLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -220282,12 +220282,12 @@ pub static WORD_APPLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_APPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLI_CHILDREN),
+static WORD_APPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("acable"),
@@ -220387,12 +220387,12 @@ pub static WORD_APPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_APPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLC_CHILDREN),
+static WORD_APPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -220408,12 +220408,12 @@ pub static WORD_APPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_APPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLA_CHILDREN),
+static WORD_APPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inces"),
         dictgen::InsensitiveStr::Ascii("udes"),
@@ -220424,12 +220424,12 @@ pub static WORD_APPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_APPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPI_CHILDREN),
+static WORD_APPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cability"),
         dictgen::InsensitiveStr::Ascii("cable"),
@@ -220457,12 +220457,12 @@ pub static WORD_APPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_APPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPE_CHILDREN),
+static WORD_APPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alling"),
         dictgen::InsensitiveStr::Ascii("araing"),
@@ -220584,12 +220584,12 @@ pub static WORD_APPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_APPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPA_CHILDREN),
+static WORD_APPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -220653,12 +220653,12 @@ pub static WORD_APPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_APO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APO_CHILDREN),
+static WORD_APO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APO_CHILDREN),
     value: None,
 };
 
-pub static WORD_APO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("calipse"),
         dictgen::InsensitiveStr::Ascii("caliptic"),
@@ -220778,12 +220778,12 @@ pub static WORD_APO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_APL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APL_CHILDREN),
+static WORD_APL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APL_CHILDREN),
     value: None,
 };
 
-pub static WORD_APL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ha"),
         dictgen::InsensitiveStr::Ascii("habet"),
@@ -220841,12 +220841,12 @@ pub static WORD_APL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_API_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_API_CHILDREN),
+static WORD_API_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_API_CHILDREN),
     value: None,
 };
 
-pub static WORD_API_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_API_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("helion"),
         dictgen::InsensitiveStr::Ascii("helions"),
@@ -220856,23 +220856,23 @@ pub static WORD_API_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_APH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APH_CHILDREN),
+static WORD_APH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APH_CHILDREN),
     value: None,
 };
 
-pub static WORD_APH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("abetical")],
     values: &[&["alphabetical"]],
     range: 8..=8,
 };
 
-static WORD_APE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APE_CHILDREN),
+static WORD_APE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APE_CHILDREN),
     value: None,
 };
 
-pub static WORD_APE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -220932,23 +220932,23 @@ pub static WORD_APE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_APD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APD_CHILDREN),
+static WORD_APD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APD_CHILDREN),
     value: None,
 };
 
-pub static WORD_APD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ated")],
     values: &[&["updated"]],
     range: 4..=4,
 };
 
-static WORD_APA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APA_CHILDREN),
+static WORD_APA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("colypse"),
@@ -220998,12 +220998,12 @@ pub static WORD_APA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_AO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AO_CHILDREN),
+static WORD_AO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ache"),
         dictgen::InsensitiveStr::Ascii("but"),
@@ -221043,12 +221043,12 @@ pub static WORD_AO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_AN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AN_CHILDREN),
+static WORD_AN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AN_CHILDREN),
     value: None,
 };
 
-static WORD_AN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANA_NODE),
     Some(&WORD_ANB_NODE),
     Some(&WORD_ANC_NODE),
@@ -221077,12 +221077,12 @@ static WORD_AN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANY_CHILDREN),
+static WORD_ANY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("away"),
         dictgen::InsensitiveStr::Ascii("awy"),
@@ -221158,12 +221158,12 @@ pub static WORD_ANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ANX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANX_CHILDREN),
+static WORD_ANX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANX_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eity"),
         dictgen::InsensitiveStr::Ascii("ios"),
@@ -221185,12 +221185,12 @@ pub static WORD_ANX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ANW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANW_CHILDREN),
+static WORD_ANW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -221220,12 +221220,12 @@ pub static WORD_ANW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ANU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANU_CHILDREN),
+static WORD_ANU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alized"),
@@ -221261,12 +221261,12 @@ pub static WORD_ANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ANT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANT_CHILDREN),
+static WORD_ANT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANT_CHILDREN),
     value: None,
 };
 
-static WORD_ANT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANTA_NODE),
     None,
     None,
@@ -221295,23 +221295,23 @@ static WORD_ANT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANTY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTY_CHILDREN),
+static WORD_ANTY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hing")],
     values: &[&["anything"]],
     range: 4..=4,
 };
 
-static WORD_ANTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTR_CHILDREN),
+static WORD_ANTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actica"),
         dictgen::InsensitiveStr::Ascii("hopology"),
@@ -221331,12 +221331,12 @@ pub static WORD_ANTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ANTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTO_CHILDREN),
+static WORD_ANTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ganist"),
         dictgen::InsensitiveStr::Ascii("gonistic"),
@@ -221346,12 +221346,12 @@ pub static WORD_ANTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ANTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTI_CHILDREN),
+static WORD_ANTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alialised"),
         dictgen::InsensitiveStr::Ascii("alised"),
@@ -221445,12 +221445,12 @@ pub static WORD_ANTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_ANTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTH_CHILDREN),
+static WORD_ANTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ings"),
@@ -221474,12 +221474,12 @@ pub static WORD_ANTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=14,
 };
 
-static WORD_ANTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTE_CHILDREN),
+static WORD_ANTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cedant"),
         dictgen::InsensitiveStr::Ascii("ena"),
@@ -221499,12 +221499,12 @@ pub static WORD_ANTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ANTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTA_CHILDREN),
+static WORD_ANTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ganist"),
         dictgen::InsensitiveStr::Ascii("ganistic"),
@@ -221540,12 +221540,12 @@ pub static WORD_ANTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_ANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANS_CHILDREN),
+static WORD_ANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alisation"),
         dictgen::InsensitiveStr::Ascii("alization"),
@@ -221599,12 +221599,12 @@ pub static WORD_ANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_ANR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANR_CHILDREN),
+static WORD_ANR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achist"),
         dictgen::InsensitiveStr::Ascii("oid"),
@@ -221613,12 +221613,12 @@ pub static WORD_ANR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_ANP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANP_CHILDREN),
+static WORD_ANP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atheater"),
         dictgen::InsensitiveStr::Ascii("atheaters"),
@@ -221648,12 +221648,12 @@ pub static WORD_ANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=10,
 };
 
-static WORD_ANO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANO_CHILDREN),
+static WORD_ANO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANO_CHILDREN),
     value: None,
 };
 
-static WORD_ANO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -221682,12 +221682,12 @@ static WORD_ANO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOY_CHILDREN),
+static WORD_ANOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOY_CHILDREN),
     value: Some(&["annoy"]),
 };
 
-pub static WORD_ANOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -221707,12 +221707,12 @@ pub static WORD_ANOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ANOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOX_CHILDREN),
+static WORD_ANOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eria"),
         dictgen::InsensitiveStr::Ascii("eric"),
@@ -221721,12 +221721,12 @@ pub static WORD_ANOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ANOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOU_CHILDREN),
+static WORD_ANOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nce"),
         dictgen::InsensitiveStr::Ascii("nced"),
@@ -221746,12 +221746,12 @@ pub static WORD_ANOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ANOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOT_CHILDREN),
+static WORD_ANOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -221783,12 +221783,12 @@ pub static WORD_ANOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ANOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOR_CHILDREN),
+static WORD_ANOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eixa"),
         dictgen::InsensitiveStr::Ascii("exiac"),
@@ -221810,23 +221810,23 @@ pub static WORD_ANOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ANOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOP_CHILDREN),
+static WORD_ANOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ther")],
     values: &[&["another"]],
     range: 4..=4,
 };
 
-static WORD_ANON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANON_CHILDREN),
+static WORD_ANON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amously"),
         dictgen::InsensitiveStr::Ascii("imised"),
@@ -221886,12 +221886,12 @@ pub static WORD_ANON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ANOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOM_CHILDREN),
+static WORD_ANOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("isity"),
@@ -221915,12 +221915,12 @@ pub static WORD_ANOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ANOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOL_CHILDREN),
+static WORD_ANOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ogon"),
         dictgen::InsensitiveStr::Ascii("ogous"),
@@ -221929,12 +221929,12 @@ pub static WORD_ANOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_ANOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOH_CHILDREN),
+static WORD_ANOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -221943,12 +221943,12 @@ pub static WORD_ANOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_ANOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOE_CHILDREN),
+static WORD_ANOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rxia"),
         dictgen::InsensitiveStr::Ascii("rxic"),
@@ -221957,12 +221957,12 @@ pub static WORD_ANOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANN_CHILDREN),
+static WORD_ANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANN_CHILDREN),
     value: None,
 };
 
-static WORD_ANN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANNA_NODE),
     None,
     None,
@@ -221991,12 +221991,12 @@ static WORD_ANN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANNY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNY_CHILDREN),
+static WORD_ANNY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oance"),
         dictgen::InsensitiveStr::Ascii("oingly"),
@@ -222005,12 +222005,12 @@ pub static WORD_ANNY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_ANNU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNU_CHILDREN),
+static WORD_ANNU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aly"),
         dictgen::InsensitiveStr::Ascii("ciators"),
@@ -222020,12 +222020,12 @@ pub static WORD_ANNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ANNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNT_CHILDREN),
+static WORD_ANNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ations"),
         dictgen::InsensitiveStr::Ascii("enas"),
@@ -222035,12 +222035,12 @@ pub static WORD_ANNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ANNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANNO_CHILDREN),
+static WORD_ANNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANNO_CHILDREN),
     value: None,
 };
 
-static WORD_ANNO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANNO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANNOA_NODE),
     None,
     None,
@@ -222069,12 +222069,12 @@ static WORD_ANNO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANNOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOY_CHILDREN),
+static WORD_ANNOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ences"),
@@ -222102,12 +222102,12 @@ pub static WORD_ANNOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ANNOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOU_CHILDREN),
+static WORD_ANNOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -222173,12 +222173,12 @@ pub static WORD_ANNOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ANNOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOT_CHILDREN),
+static WORD_ANNOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aion"),
         dictgen::InsensitiveStr::Ascii("aions"),
@@ -222200,12 +222200,12 @@ pub static WORD_ANNOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ANNON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNON_CHILDREN),
+static WORD_ANNON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -222249,12 +222249,12 @@ pub static WORD_ANNON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ANNOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOI_CHILDREN),
+static WORD_ANNOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("nted"),
@@ -222265,34 +222265,34 @@ pub static WORD_ANNOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ANNOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOA_CHILDREN),
+static WORD_ANNOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["annotation"]],
     range: 4..=4,
 };
 
-static WORD_ANNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNN_CHILDREN),
+static WORD_ANNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ounce")],
     values: &[&["announce"]],
     range: 5..=5,
 };
 
-static WORD_ANNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNI_CHILDREN),
+static WORD_ANNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("halated"),
         dictgen::InsensitiveStr::Ascii("halition"),
@@ -222338,34 +222338,34 @@ pub static WORD_ANNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ANNH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNH_CHILDREN),
+static WORD_ANNH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iliation")],
     values: &[&["annihilation"]],
     range: 8..=8,
 };
 
-static WORD_ANND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANND_CHILDREN),
+static WORD_ANND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANND_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ANNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNA_CHILDREN),
+static WORD_ANNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("verseries"),
         dictgen::InsensitiveStr::Ascii("versery"),
@@ -222387,12 +222387,12 @@ pub static WORD_ANNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ANM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANM_CHILDREN),
+static WORD_ANM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("esia"),
@@ -222402,12 +222402,12 @@ pub static WORD_ANM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_ANL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANL_CHILDREN),
+static WORD_ANL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayses"),
         dictgen::InsensitiveStr::Ascii("aysis"),
@@ -222433,12 +222433,12 @@ pub static WORD_ANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ANK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANK_CHILDREN),
+static WORD_ANK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("shios"),
         dictgen::InsensitiveStr::Ascii("shiosly"),
@@ -222470,23 +222470,23 @@ pub static WORD_ANK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ANJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANJ_CHILDREN),
+static WORD_ANJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("anew")],
     values: &[&["ingenue"]],
     range: 4..=4,
 };
 
-static WORD_ANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANI_CHILDREN),
+static WORD_ANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("alated"),
@@ -222600,23 +222600,23 @@ pub static WORD_ANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=13,
 };
 
-static WORD_ANH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANH_CHILDREN),
+static WORD_ANH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oter")],
     values: &[&["another"]],
     range: 4..=4,
 };
 
-static WORD_ANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANG_CHILDREN),
+static WORD_ANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irly"),
         dictgen::InsensitiveStr::Ascii("luar"),
@@ -222668,23 +222668,23 @@ pub static WORD_ANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ANF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANF_CHILDREN),
+static WORD_ANF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANF_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["and"]],
     range: 1..=1,
 };
 
-static WORD_ANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANE_CHILDREN),
+static WORD_ANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANE_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cdatally"),
         dictgen::InsensitiveStr::Ascii("cdotale"),
@@ -222752,12 +222752,12 @@ pub static WORD_ANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_AND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AND_CHILDREN),
+static WORD_AND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AND_CHILDREN),
     value: None,
 };
 
-pub static WORD_AND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("elabra"),
@@ -222809,12 +222809,12 @@ pub static WORD_AND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ANC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANC_CHILDREN),
+static WORD_ANC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANC_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apsulate"),
         dictgen::InsensitiveStr::Ascii("apsulated"),
@@ -222872,23 +222872,23 @@ pub static WORD_ANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ANB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANB_CHILDREN),
+static WORD_ANB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["and"]],
     range: 1..=1,
 };
 
-static WORD_ANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANA_CHILDREN),
+static WORD_ANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANA_CHILDREN),
     value: None,
 };
 
-static WORD_ANA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_ANAC_NODE),
@@ -222917,12 +222917,12 @@ static WORD_ANA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAY_CHILDREN),
+static WORD_ANAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lse"),
         dictgen::InsensitiveStr::Ascii("lsed"),
@@ -222968,12 +222968,12 @@ pub static WORD_ANAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ANAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAR_CHILDREN),
+static WORD_ANAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chim"),
         dictgen::InsensitiveStr::Ascii("chisim"),
@@ -223013,34 +223013,34 @@ pub static WORD_ANAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ANAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAO_CHILDREN),
+static WORD_ANAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lgue")],
     values: &[&["analogue"]],
     range: 4..=4,
 };
 
-static WORD_ANAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAN_CHILDREN),
+static WORD_ANAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("log")],
     values: &[&["analog"]],
     range: 3..=3,
 };
 
-static WORD_ANAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANAL_CHILDREN),
+static WORD_ANAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANAL_CHILDREN),
     value: None,
 };
 
-static WORD_ANAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANALA_NODE),
     None,
     None,
@@ -223069,12 +223069,12 @@ static WORD_ANAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANALZ_NODE),
 ];
 
-static WORD_ANALZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALZ_CHILDREN),
+static WORD_ANALZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ye"),
@@ -223096,12 +223096,12 @@ pub static WORD_ANALZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ANALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALY_CHILDREN),
+static WORD_ANALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -223183,23 +223183,23 @@ pub static WORD_ANALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ANALT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALT_CHILDREN),
+static WORD_ANALT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("yics")],
     values: &[&["analytics"]],
     range: 4..=4,
 };
 
-static WORD_ANALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALS_CHILDREN),
+static WORD_ANALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ye"),
         dictgen::InsensitiveStr::Ascii("yed"),
@@ -223227,12 +223227,12 @@ pub static WORD_ANALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ANALO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALO_CHILDREN),
+static WORD_ANALO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("geous"),
@@ -223256,12 +223256,12 @@ pub static WORD_ANALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ANALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALI_CHILDREN),
+static WORD_ANALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -223307,12 +223307,12 @@ pub static WORD_ANALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ANALG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALG_CHILDREN),
+static WORD_ANALG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oue"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -223321,12 +223321,12 @@ pub static WORD_ANALG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_ANALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALA_CHILDREN),
+static WORD_ANALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gous"),
         dictgen::InsensitiveStr::Ascii("gus"),
@@ -223337,45 +223337,45 @@ pub static WORD_ANALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ANAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAG_CHILDREN),
+static WORD_ANAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["manager", "anger"]],
     range: 2..=2,
 };
 
-static WORD_ANAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAD_CHILDREN),
+static WORD_ANAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAD_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ANAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAC_CHILDREN),
+static WORD_ANAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hrist")],
     values: &[&["anarchist"]],
     range: 5..=5,
 };
 
-static WORD_AM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AM_CHILDREN),
+static WORD_AM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AM_CHILDREN),
     value: None,
 };
 
-static WORD_AM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AMA_NODE),
     Some(&WORD_AMB_NODE),
     None,
@@ -223404,12 +223404,12 @@ static WORD_AM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_AMZ_NODE),
 ];
 
-static WORD_AMZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMZ_CHILDREN),
+static WORD_AMZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -223418,12 +223418,12 @@ pub static WORD_AMZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_AMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMU_CHILDREN),
+static WORD_AMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blance"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -223441,23 +223441,23 @@ pub static WORD_AMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_AMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMT_CHILDREN),
+static WORD_AMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("heyst")],
     values: &[&["amethyst"]],
     range: 5..=5,
 };
 
-static WORD_AMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMR_CHILDREN),
+static WORD_AMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ageddon"),
         dictgen::InsensitiveStr::Ascii("chair"),
@@ -223475,12 +223475,12 @@ pub static WORD_AMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_AMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMP_CHILDREN),
+static WORD_AMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atheater"),
         dictgen::InsensitiveStr::Ascii("atheaters"),
@@ -223552,12 +223552,12 @@ pub static WORD_AMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_AMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMO_CHILDREN),
+static WORD_AMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gnst"),
         dictgen::InsensitiveStr::Ascii("hetamines"),
@@ -223599,12 +223599,12 @@ pub static WORD_AMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_AMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMN_CHILDREN),
+static WORD_AMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eisa"),
         dictgen::InsensitiveStr::Ascii("estry"),
@@ -223615,12 +223615,12 @@ pub static WORD_AMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_AMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMM_CHILDREN),
+static WORD_AMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("end"),
         dictgen::InsensitiveStr::Ascii("ended"),
@@ -223662,23 +223662,23 @@ pub static WORD_AMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_AML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AML_CHILDREN),
+static WORD_AML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AML_CHILDREN),
     value: None,
 };
 
-pub static WORD_AML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pifier")],
     values: &[&["amplifier"]],
     range: 6..=6,
 };
 
-static WORD_AMK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMK_CHILDREN),
+static WORD_AMK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMK_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -223687,12 +223687,12 @@ pub static WORD_AMK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_AMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMI_CHILDREN),
+static WORD_AMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bguity"),
         dictgen::InsensitiveStr::Ascii("guity"),
@@ -223708,12 +223708,12 @@ pub static WORD_AMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_AMG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMG_CHILDREN),
+static WORD_AMG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iguous"),
         dictgen::InsensitiveStr::Ascii("le"),
@@ -223723,12 +223723,12 @@ pub static WORD_AMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_AME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AME_CHILDREN),
+static WORD_AME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AME_CHILDREN),
     value: None,
 };
 
-static WORD_AME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AMEA_NODE),
     None,
     None,
@@ -223757,34 +223757,34 @@ static WORD_AME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AMEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEY_CHILDREN),
+static WORD_AMEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("thst")],
     values: &[&["amethyst"]],
     range: 4..=4,
 };
 
-static WORD_AMET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMET_CHILDREN),
+static WORD_AMET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMET_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hsyt")],
     values: &[&["amethyst"]],
     range: 4..=4,
 };
 
-static WORD_AMER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMER_CHILDREN),
+static WORD_AMER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMER_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cia"),
         dictgen::InsensitiveStr::Ascii("cian"),
@@ -223838,12 +223838,12 @@ pub static WORD_AMER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_AMEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEN_CHILDREN),
+static WORD_AMEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dement"),
         dictgen::InsensitiveStr::Ascii("dmant"),
@@ -223869,12 +223869,12 @@ pub static WORD_AMEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_AMEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEL_CHILDREN),
+static WORD_AMEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earate"),
         dictgen::InsensitiveStr::Ascii("earated"),
@@ -223894,12 +223894,12 @@ pub static WORD_AMEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_AMEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEE_CHILDREN),
+static WORD_AMEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("larate"),
         dictgen::InsensitiveStr::Ascii("larated"),
@@ -223931,12 +223931,12 @@ pub static WORD_AMEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_AMEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEA_CHILDREN),
+static WORD_AMEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("learate"),
         dictgen::InsensitiveStr::Ascii("learated"),
@@ -223968,12 +223968,12 @@ pub static WORD_AMEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_AMD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMD_CHILDREN),
+static WORD_AMD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMD_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("gput"),
@@ -223982,12 +223982,12 @@ pub static WORD_AMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_AMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMB_CHILDREN),
+static WORD_AMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adexterous"),
         dictgen::InsensitiveStr::Ascii("adexterouseness"),
@@ -224065,12 +224065,12 @@ pub static WORD_AMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=15,
 };
 
-static WORD_AMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMA_CHILDREN),
+static WORD_AMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("cingly"),
@@ -224116,12 +224116,12 @@ pub static WORD_AMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_AL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AL_CHILDREN),
+static WORD_AL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AL_CHILDREN),
     value: None,
 };
 
-static WORD_AL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ALA_NODE),
     Some(&WORD_ALB_NODE),
     Some(&WORD_ALC_NODE),
@@ -224150,23 +224150,23 @@ static WORD_AL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALY_CHILDREN),
+static WORD_ALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ways")],
     values: &[&["always"]],
     range: 4..=4,
 };
 
-static WORD_ALW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALW_CHILDREN),
+static WORD_ALW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ais"),
         dictgen::InsensitiveStr::Ascii("ans"),
@@ -224200,12 +224200,12 @@ pub static WORD_ALW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ALV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALV_CHILDREN),
+static WORD_ALV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orithm"),
         dictgen::InsensitiveStr::Ascii("orithmic"),
@@ -224221,12 +224221,12 @@ pub static WORD_ALV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=12,
 };
 
-static WORD_ALU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALU_CHILDREN),
+static WORD_ALU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("minim"),
@@ -224246,12 +224246,12 @@ pub static WORD_ALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ALT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALT_CHILDREN),
+static WORD_ALT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALT_CHILDREN),
     value: None,
 };
 
-static WORD_ALT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ALTA_NODE),
     None,
     None,
@@ -224280,12 +224280,12 @@ static WORD_ALT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTU_CHILDREN),
+static WORD_ALTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rism"),
         dictgen::InsensitiveStr::Ascii("ristic"),
@@ -224294,12 +224294,12 @@ pub static WORD_ALTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ALTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTR_CHILDREN),
+static WORD_ALTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eady"),
         dictgen::InsensitiveStr::Ascii("iusm"),
@@ -224327,12 +224327,12 @@ pub static WORD_ALTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_ALTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTO_CHILDREN),
+static WORD_ALTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gehter"),
         dictgen::InsensitiveStr::Ascii("gheter"),
@@ -224348,23 +224348,23 @@ pub static WORD_ALTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ALTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTN_CHILDREN),
+static WORD_ALTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erately")],
     values: &[&["alternately"]],
     range: 7..=7,
 };
 
-static WORD_ALTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTI_CHILDREN),
+static WORD_ALTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tide"),
         dictgen::InsensitiveStr::Ascii("tute"),
@@ -224373,12 +224373,12 @@ pub static WORD_ALTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ALTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTH_CHILDREN),
+static WORD_ALTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etes"),
         dictgen::InsensitiveStr::Ascii("etic"),
@@ -224414,12 +224414,12 @@ pub static WORD_ALTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_ALTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTE_CHILDREN),
+static WORD_ALTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("nate"),
@@ -224551,12 +224551,12 @@ pub static WORD_ALTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_ALTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTA_CHILDREN),
+static WORD_ALTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nta"),
         dictgen::InsensitiveStr::Ascii("ntic"),
@@ -224566,12 +224566,12 @@ pub static WORD_ALTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALS_CHILDREN),
+static WORD_ALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALS_CHILDREN),
     value: Some(&["also"]),
 };
 
-pub static WORD_ALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("most"),
@@ -224591,12 +224591,12 @@ pub static WORD_ALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ALR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALR_CHILDREN),
+static WORD_ALR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ady"),
         dictgen::InsensitiveStr::Ascii("aedy"),
@@ -224652,12 +224652,12 @@ pub static WORD_ALR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ALP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALP_CHILDREN),
+static WORD_ALP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abet"),
         dictgen::InsensitiveStr::Ascii("abetic"),
@@ -224703,12 +224703,12 @@ pub static WORD_ALP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_ALO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALO_CHILDREN),
+static WORD_ALO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALO_CHILDREN),
     value: Some(&["also"]),
 };
 
-pub static WORD_ALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("catable"),
@@ -224796,23 +224796,23 @@ pub static WORD_ALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_ALN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALN_CHILDREN),
+static WORD_ALN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("terating")],
     values: &[&["alternating"]],
     range: 8..=8,
 };
 
-static WORD_ALM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALM_CHILDREN),
+static WORD_ALM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aost"),
         dictgen::InsensitiveStr::Ascii("ightly"),
@@ -224834,12 +224834,12 @@ pub static WORD_ALM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_ALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALL_CHILDREN),
+static WORD_ALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALL_CHILDREN),
     value: None,
 };
 
-static WORD_ALL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ALLA_NODE),
     None,
     Some(&WORD_ALLC_NODE),
@@ -224868,12 +224868,12 @@ static WORD_ALL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALLW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLW_CHILDREN),
+static WORD_ALLW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ays"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -224893,12 +224893,12 @@ pub static WORD_ALLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_ALLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLT_CHILDREN),
+static WORD_ALLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernate"),
         dictgen::InsensitiveStr::Ascii("hough"),
@@ -224922,23 +224922,23 @@ pub static WORD_ALLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_ALLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLS_CHILDREN),
+static WORD_ALLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLS_CHILDREN),
     value: Some(&["all", "falls"]),
 };
 
-pub static WORD_ALLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("o")],
     values: &[&["also"]],
     range: 1..=1,
 };
 
-static WORD_ALLR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLR_CHILDREN),
+static WORD_ALLR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eady"),
         dictgen::InsensitiveStr::Ascii("edy"),
@@ -224949,12 +224949,12 @@ pub static WORD_ALLR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ALLP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLP_CHILDREN),
+static WORD_ALLP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -224963,12 +224963,12 @@ pub static WORD_ALLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_ALLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALLO_CHILDREN),
+static WORD_ALLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALLO_CHILDREN),
     value: Some(&["allow"]),
 };
 
-static WORD_ALLO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALLO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ALLOA_NODE),
     None,
     Some(&WORD_ALLOC_NODE),
@@ -224997,12 +224997,12 @@ static WORD_ALLO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALLOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOW_CHILDREN),
+static WORD_ALLOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -225020,56 +225020,56 @@ pub static WORD_ALLOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ALLOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOV_CHILDREN),
+static WORD_ALLOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["allowed"]],
     range: 2..=2,
 };
 
-static WORD_ALLOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOU_CHILDREN),
+static WORD_ALLOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["aloud", "allowed"]],
     range: 1..=1,
 };
 
-static WORD_ALLOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOT_CHILDREN),
+static WORD_ALLOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["allotted"]],
     range: 2..=2,
 };
 
-static WORD_ALLOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOS_CHILDREN),
+static WORD_ALLOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOS_CHILDREN),
     value: Some(&["allows"]),
 };
 
-pub static WORD_ALLOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ALLOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOP_CHILDREN),
+static WORD_ALLOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("one"),
         dictgen::InsensitiveStr::Ascii("ones"),
@@ -225078,23 +225078,23 @@ pub static WORD_ALLOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ALLOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOO_CHILDREN),
+static WORD_ALLOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cates")],
     values: &[&["allocates"]],
     range: 5..=5,
 };
 
-static WORD_ALLON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLON_CHILDREN),
+static WORD_ALLON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -225103,12 +225103,12 @@ pub static WORD_ALLON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=1,
 };
 
-static WORD_ALLOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOE_CHILDREN),
+static WORD_ALLOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ws"),
@@ -225117,12 +225117,12 @@ pub static WORD_ALLOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_ALLOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOC_CHILDREN),
+static WORD_ALLOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -225222,12 +225222,12 @@ pub static WORD_ALLOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ALLOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOA_CHILDREN),
+static WORD_ALLOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cte"),
@@ -225243,23 +225243,23 @@ pub static WORD_ALLOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ALLM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLM_CHILDREN),
+static WORD_ALLM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ost")],
     values: &[&["almost"]],
     range: 3..=3,
 };
 
-static WORD_ALLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLL_CHILDREN),
+static WORD_ALLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLL_CHILDREN),
     value: Some(&["all"]),
 };
 
-pub static WORD_ALLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocate"),
         dictgen::InsensitiveStr::Ascii("ocation"),
@@ -225277,23 +225277,23 @@ pub static WORD_ALLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ALLK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLK_CHILDREN),
+static WORD_ALLK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLK_CHILDREN),
     value: Some(&["all"]),
 };
 
-pub static WORD_ALLK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ALLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLI_CHILDREN),
+static WORD_ALLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anse"),
         dictgen::InsensitiveStr::Ascii("asing"),
@@ -225333,12 +225333,12 @@ pub static WORD_ALLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_ALLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLE_CHILDREN),
+static WORD_ALLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLE_CHILDREN),
     value: Some(&["all", "alley"]),
 };
 
-pub static WORD_ALLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dge"),
@@ -225388,12 +225388,12 @@ pub static WORD_ALLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_ALLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLC_CHILDREN),
+static WORD_ALLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ateing"),
@@ -225437,12 +225437,12 @@ pub static WORD_ALLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ALLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLA_CHILDREN),
+static WORD_ALLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("critty"),
         dictgen::InsensitiveStr::Ascii("ince"),
@@ -225452,12 +225452,12 @@ pub static WORD_ALLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALI_CHILDREN),
+static WORD_ALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agn"),
         dictgen::InsensitiveStr::Ascii("asas"),
@@ -225581,12 +225581,12 @@ pub static WORD_ALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ALH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALH_CHILDREN),
+static WORD_ALH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("abet"),
@@ -225632,12 +225632,12 @@ pub static WORD_ALH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_ALG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALG_CHILDREN),
+static WORD_ALG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALG_CHILDREN),
     value: None,
 };
 
-static WORD_ALG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -225666,23 +225666,23 @@ static WORD_ALG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGR_CHILDREN),
+static WORD_ALGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ithm")],
     values: &[&["algorithm"]],
     range: 4..=4,
 };
 
-static WORD_ALGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALGO_CHILDREN),
+static WORD_ALGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALGO_CHILDREN),
     value: None,
 };
 
-static WORD_ALGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALGO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -225711,12 +225711,12 @@ static WORD_ALGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALGOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOT_CHILDREN),
+static WORD_ALGOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hitm"),
         dictgen::InsensitiveStr::Ascii("hitmic"),
@@ -225772,12 +225772,12 @@ pub static WORD_ALGOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_ALGOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALGOR_CHILDREN),
+static WORD_ALGOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALGOR_CHILDREN),
     value: None,
 };
 
-static WORD_ALGOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALGOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -225806,12 +225806,12 @@ static WORD_ALGOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALGORY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORY_CHILDREN),
+static WORD_ALGORY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("them"),
         dictgen::InsensitiveStr::Ascii("themic"),
@@ -225837,12 +225837,12 @@ pub static WORD_ALGORY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=10,
 };
 
-static WORD_ALGORW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORW_CHILDREN),
+static WORD_ALGORW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("withm"),
         dictgen::InsensitiveStr::Ascii("withmic"),
@@ -225858,12 +225858,12 @@ pub static WORD_ALGORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=11,
 };
 
-static WORD_ALGORU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORU_CHILDREN),
+static WORD_ALGORU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thm"),
         dictgen::InsensitiveStr::Ascii("thmic"),
@@ -225879,12 +225879,12 @@ pub static WORD_ALGORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_ALGORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORT_CHILDREN),
+static WORD_ALGORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("him"),
         dictgen::InsensitiveStr::Ascii("himic"),
@@ -225972,12 +225972,12 @@ pub static WORD_ALGORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_ALGORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORR_CHILDREN),
+static WORD_ALGORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226001,12 +226001,12 @@ pub static WORD_ALGORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=10,
 };
 
-static WORD_ALGORO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORO_CHILDREN),
+static WORD_ALGORO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226038,12 +226038,12 @@ pub static WORD_ALGORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=11,
 };
 
-static WORD_ALGORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORI_CHILDREN),
+static WORD_ALGORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghtm"),
         dictgen::InsensitiveStr::Ascii("ghtmic"),
@@ -226161,12 +226161,12 @@ pub static WORD_ALGORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_ALGORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORH_CHILDREN),
+static WORD_ALGORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226214,12 +226214,12 @@ pub static WORD_ALGORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_ALGORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORG_CHILDREN),
+static WORD_ALGORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226235,12 +226235,12 @@ pub static WORD_ALGORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=10,
 };
 
-static WORD_ALGOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOP_CHILDREN),
+static WORD_ALGOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rithm"),
         dictgen::InsensitiveStr::Ascii("rithmic"),
@@ -226256,12 +226256,12 @@ pub static WORD_ALGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ALGOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOO_CHILDREN),
+static WORD_ALGOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rithm"),
         dictgen::InsensitiveStr::Ascii("rithmic"),
@@ -226277,12 +226277,12 @@ pub static WORD_ALGOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ALGOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOL_CHILDREN),
+static WORD_ALGOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226298,12 +226298,12 @@ pub static WORD_ALGOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_ALGOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOI_CHILDREN),
+static WORD_ALGOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rthm"),
         dictgen::InsensitiveStr::Ascii("rthmic"),
@@ -226327,12 +226327,12 @@ pub static WORD_ALGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ALGOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOH_CHILDREN),
+static WORD_ALGOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mic"),
@@ -226348,12 +226348,12 @@ pub static WORD_ALGOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ALGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGI_CHILDREN),
+static WORD_ALGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ned"),
         dictgen::InsensitiveStr::Ascii("nment"),
@@ -226363,12 +226363,12 @@ pub static WORD_ALGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ALGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGH_CHILDREN),
+static WORD_ALGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orithm"),
         dictgen::InsensitiveStr::Ascii("orithms"),
@@ -226388,12 +226388,12 @@ pub static WORD_ALGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ALGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGE_CHILDREN),
+static WORD_ALGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("braical"),
         dictgen::InsensitiveStr::Ascii("briac"),
@@ -226413,12 +226413,12 @@ pub static WORD_ALGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ALF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALF_CHILDREN),
+static WORD_ALF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orithm"),
         dictgen::InsensitiveStr::Ascii("orithmic"),
@@ -226434,12 +226434,12 @@ pub static WORD_ALF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=12,
 };
 
-static WORD_ALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALE_CHILDREN),
+static WORD_ALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ady"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -226495,23 +226495,23 @@ pub static WORD_ALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ALD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALD_CHILDREN),
+static WORD_ALD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utery")],
     values: &[&["adultery"]],
     range: 5..=5,
 };
 
-static WORD_ALC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALC_CHILDREN),
+static WORD_ALC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ehmist"),
         dictgen::InsensitiveStr::Ascii("emy"),
@@ -226567,12 +226567,12 @@ pub static WORD_ALC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ALB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALB_CHILDREN),
+static WORD_ALB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iet"),
         dictgen::InsensitiveStr::Ascii("umns"),
@@ -226581,12 +226581,12 @@ pub static WORD_ALB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_ALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALA_CHILDREN),
+static WORD_ALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("is"),
         dictgen::InsensitiveStr::Ascii("ising"),
@@ -226597,12 +226597,12 @@ pub static WORD_ALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_AK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AK_CHILDREN),
+static WORD_AK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AK_CHILDREN),
     value: None,
 };
 
-pub static WORD_AK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("kumulate"),
@@ -226666,12 +226666,12 @@ pub static WORD_AK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_AJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AJ_CHILDREN),
+static WORD_AJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_AJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acence"),
         dictgen::InsensitiveStr::Ascii("acencies"),
@@ -226715,12 +226715,12 @@ pub static WORD_AJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_AI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AI_CHILDREN),
+static WORD_AI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("craft"),
         dictgen::InsensitiveStr::Ascii("ffer"),
@@ -226800,12 +226800,12 @@ pub static WORD_AI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_AH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AH_CHILDREN),
+static WORD_AH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AH_CHILDREN),
     value: None,
 };
 
-pub static WORD_AH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aed"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -226849,12 +226849,12 @@ pub static WORD_AH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_AG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AG_CHILDREN),
+static WORD_AG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AG_CHILDREN),
     value: None,
 };
 
-static WORD_AG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AGA_NODE),
     None,
     None,
@@ -226883,12 +226883,12 @@ static WORD_AG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGU_CHILDREN),
+static WORD_AGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mented"),
@@ -226899,23 +226899,23 @@ pub static WORD_AGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_AGS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGS_CHILDREN),
+static WORD_AGS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGS_CHILDREN),
     value: Some(&["ages", "tags"]),
 };
 
-pub static WORD_AGS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inst")],
     values: &[&["against"]],
     range: 4..=4,
 };
 
-static WORD_AGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AGR_CHILDREN),
+static WORD_AGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AGR_CHILDREN),
     value: None,
 };
 
-static WORD_AGR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AGR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AGRA_NODE),
     None,
     None,
@@ -226944,12 +226944,12 @@ static WORD_AGR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AGRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRU_CHILDREN),
+static WORD_AGRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ably"),
@@ -226971,12 +226971,12 @@ pub static WORD_AGRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_AGRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRR_CHILDREN),
+static WORD_AGRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ement"),
@@ -226986,23 +226986,23 @@ pub static WORD_AGRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_AGRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRO_CHILDREN),
+static WORD_AGRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cultural")],
     values: &[&["agricultural"]],
     range: 8..=8,
 };
 
-static WORD_AGRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRI_CHILDREN),
+static WORD_AGRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("colture"),
         dictgen::InsensitiveStr::Ascii("culteral"),
@@ -227042,12 +227042,12 @@ pub static WORD_AGRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_AGRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRG_CHILDREN),
+static WORD_AGRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ressive"),
         dictgen::InsensitiveStr::Ascii("ressively"),
@@ -227063,12 +227063,12 @@ pub static WORD_AGRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_AGRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRE_CHILDREN),
+static WORD_AGRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("eded"),
@@ -227132,12 +227132,12 @@ pub static WORD_AGRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_AGRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRA_CHILDREN),
+static WORD_AGRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cultural"),
         dictgen::InsensitiveStr::Ascii("gates"),
@@ -227161,12 +227161,12 @@ pub static WORD_AGRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_AGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGO_CHILDREN),
+static WORD_AGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nstic"),
         dictgen::InsensitiveStr::Ascii("nsticism"),
@@ -227176,12 +227176,12 @@ pub static WORD_AGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_AGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGN_CHILDREN),
+static WORD_AGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ositc"),
         dictgen::InsensitiveStr::Ascii("ostacism"),
@@ -227215,12 +227215,12 @@ pub static WORD_AGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_AGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGL_CHILDREN),
+static WORD_AGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orithm"),
         dictgen::InsensitiveStr::Ascii("orithms"),
@@ -227229,23 +227229,23 @@ pub static WORD_AGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_AGK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGK_CHILDREN),
+static WORD_AGK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGK_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nowledged")],
     values: &[&["acknowledged"]],
     range: 9..=9,
 };
 
-static WORD_AGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGI_CHILDREN),
+static WORD_AGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("anst"),
@@ -227267,12 +227267,12 @@ pub static WORD_AGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_AGG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGG_CHILDREN),
+static WORD_AGG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aravates"),
         dictgen::InsensitiveStr::Ascii("egate"),
@@ -227394,12 +227394,12 @@ pub static WORD_AGG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_AGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGA_CHILDREN),
+static WORD_AGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("innst"),
@@ -227437,12 +227437,12 @@ pub static WORD_AGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_AF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AF_CHILDREN),
+static WORD_AF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AF_CHILDREN),
     value: None,
 };
 
-static WORD_AF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AFA_NODE),
     None,
     None,
@@ -227471,23 +227471,23 @@ static WORD_AF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AFW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFW_CHILDREN),
+static WORD_AFW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFW_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ully")],
     values: &[&["awfully"]],
     range: 4..=4,
 };
 
-static WORD_AFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFT_CHILDREN),
+static WORD_AFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("erawards"),
@@ -227533,12 +227533,12 @@ pub static WORD_AFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_AFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFR_CHILDREN),
+static WORD_AFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("iad"),
@@ -227562,12 +227562,12 @@ pub static WORD_AFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_AFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFO_CHILDREN),
+static WORD_AFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rd"),
@@ -227589,12 +227589,12 @@ pub static WORD_AFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_AFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFI_CHILDREN),
+static WORD_AFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nity"),
         dictgen::InsensitiveStr::Ascii("rcan"),
@@ -227604,23 +227604,23 @@ pub static WORD_AFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_AFH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFH_CHILDREN),
+static WORD_AFH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFH_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ganistan")],
     values: &[&["afghanistan"]],
     range: 8..=8,
 };
 
-static WORD_AFG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFG_CHILDREN),
+static WORD_AFG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahnistan"),
         dictgen::InsensitiveStr::Ascii("anhistan"),
@@ -227638,12 +227638,12 @@ pub static WORD_AFG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=9,
 };
 
-static WORD_AFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFF_CHILDREN),
+static WORD_AFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("aires"),
@@ -227759,12 +227759,12 @@ pub static WORD_AFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_AFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFE_CHILDREN),
+static WORD_AFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFE_CHILDREN),
     value: Some(&["safe"]),
 };
 
-pub static WORD_AFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cting"),
@@ -227786,12 +227786,12 @@ pub static WORD_AFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_AFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFA_CHILDREN),
+static WORD_AFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ir"),
         dictgen::InsensitiveStr::Ascii("raid"),
@@ -227800,12 +227800,12 @@ pub static WORD_AFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_AE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AE_CHILDREN),
+static WORD_AE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("activate"),
         dictgen::InsensitiveStr::Ascii("orspace"),
@@ -227863,12 +227863,12 @@ pub static WORD_AE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_AD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AD_CHILDREN),
+static WORD_AD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AD_CHILDREN),
     value: None,
 };
 
-static WORD_AD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AD_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ADA_NODE),
     Some(&WORD_ADB_NODE),
     None,
@@ -227897,23 +227897,23 @@ static WORD_AD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADW_CHILDREN),
+static WORD_ADW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ances")],
     values: &[&["advances"]],
     range: 5..=5,
 };
 
-static WORD_ADV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ADV_CHILDREN),
+static WORD_ADV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ADV_CHILDREN),
     value: None,
 };
 
-static WORD_ADV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ADV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ADVA_NODE),
     None,
     None,
@@ -227942,12 +227942,12 @@ static WORD_ADV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVS_CHILDREN),
+static WORD_ADVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -227958,12 +227958,12 @@ pub static WORD_ADVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ADVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVO_CHILDREN),
+static WORD_ADVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cade"),
         dictgen::InsensitiveStr::Ascii("cats"),
@@ -227973,12 +227973,12 @@ pub static WORD_ADVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ADVN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVN_CHILDREN),
+static WORD_ADVN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -227987,12 +227987,12 @@ pub static WORD_ADVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_ADVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVI_CHILDREN),
+static WORD_ADVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -228024,12 +228024,12 @@ pub static WORD_ADVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ADVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVE_CHILDREN),
+static WORD_ADVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nced"),
         dictgen::InsensitiveStr::Ascii("ntageous"),
@@ -228123,12 +228123,12 @@ pub static WORD_ADVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ADVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVA_CHILDREN),
+static WORD_ADVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cne"),
@@ -228174,12 +228174,12 @@ pub static WORD_ADVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ADU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADU_CHILDREN),
+static WORD_ADU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iobook"),
         dictgen::InsensitiveStr::Ascii("ltey"),
@@ -228197,12 +228197,12 @@ pub static WORD_ADU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ADT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADT_CHILDREN),
+static WORD_ADT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("odetect"),
@@ -228211,12 +228211,12 @@ pub static WORD_ADT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ADR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADR_CHILDREN),
+static WORD_ADR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ea"),
         dictgen::InsensitiveStr::Ascii("eanline"),
@@ -228272,12 +228272,12 @@ pub static WORD_ADR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ADQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADQ_CHILDREN),
+static WORD_ADQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uire"),
         dictgen::InsensitiveStr::Ascii("uired"),
@@ -228288,12 +228288,12 @@ pub static WORD_ADQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ADP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADP_CHILDREN),
+static WORD_ADP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apted"),
         dictgen::InsensitiveStr::Ascii("apter"),
@@ -228321,12 +228321,12 @@ pub static WORD_ADP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ADO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADO_CHILDREN),
+static WORD_ADO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bted"),
         dictgen::InsensitiveStr::Ascii("lecent"),
@@ -228368,23 +228368,23 @@ pub static WORD_ADO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_ADN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADN_CHILDREN),
+static WORD_ADN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADN_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ADN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("imistrator")],
     values: &[&["administrators"]],
     range: 10..=10,
 };
 
-static WORD_ADM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ADM_CHILDREN),
+static WORD_ADM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ADM_CHILDREN),
     value: None,
 };
 
-static WORD_ADM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ADM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -228413,23 +228413,23 @@ static WORD_ADM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMR_CHILDREN),
+static WORD_ADMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ial")],
     values: &[&["admiral"]],
     range: 3..=3,
 };
 
-static WORD_ADMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMN_CHILDREN),
+static WORD_ADMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMN_CHILDREN),
     value: Some(&["admin"]),
 };
 
-pub static WORD_ADMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("istrator"),
         dictgen::InsensitiveStr::Ascii("istrators"),
@@ -228438,12 +228438,12 @@ pub static WORD_ADMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_ADMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ADMI_CHILDREN),
+static WORD_ADMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ADMI_CHILDREN),
     value: Some(&["admin"]),
 };
 
-static WORD_ADMI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ADMI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -228472,12 +228472,12 @@ static WORD_ADMI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADMIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMIT_CHILDREN),
+static WORD_ADMIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("edly"),
@@ -228497,12 +228497,12 @@ pub static WORD_ADMIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ADMIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMIS_CHILDREN),
+static WORD_ADMIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ible"),
         dictgen::InsensitiveStr::Ascii("sability"),
@@ -228518,23 +228518,23 @@ pub static WORD_ADMIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_ADMIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMIR_CHILDREN),
+static WORD_ADMIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aal")],
     values: &[&["admiral"]],
     range: 3..=3,
 };
 
-static WORD_ADMIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMIN_CHILDREN),
+static WORD_ADMIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("astrator"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -228648,23 +228648,23 @@ pub static WORD_ADMIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_ADME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADME_CHILDREN),
+static WORD_ADME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADME_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ndment")],
     values: &[&["amendment"]],
     range: 6..=6,
 };
 
-static WORD_ADK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADK_CHILDREN),
+static WORD_ADK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nowledged"),
         dictgen::InsensitiveStr::Ascii("nowledges"),
@@ -228673,12 +228673,12 @@ pub static WORD_ADK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=9,
 };
 
-static WORD_ADJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADJ_CHILDREN),
+static WORD_ADJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acancy"),
         dictgen::InsensitiveStr::Ascii("acentcy"),
@@ -228782,12 +228782,12 @@ pub static WORD_ADJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_ADI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADI_CHILDREN),
+static WORD_ADI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acent"),
         dictgen::InsensitiveStr::Ascii("diton"),
@@ -228831,12 +228831,12 @@ pub static WORD_ADI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ADH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADH_CHILDREN),
+static WORD_ADH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earing"),
         dictgen::InsensitiveStr::Ascii("easive"),
@@ -228856,12 +228856,12 @@ pub static WORD_ADH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_ADG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADG_CHILDREN),
+static WORD_ADG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -228870,23 +228870,23 @@ pub static WORD_ADG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_ADF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADF_CHILDREN),
+static WORD_ADF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["after"]],
     range: 3..=3,
 };
 
-static WORD_ADE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADE_CHILDREN),
+static WORD_ADE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alide"),
         dictgen::InsensitiveStr::Ascii("cuate"),
@@ -228936,12 +228936,12 @@ pub static WORD_ADE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ADD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ADD_CHILDREN),
+static WORD_ADD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ADD_CHILDREN),
     value: None,
 };
 
-static WORD_ADD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ADD_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ADDA_NODE),
     None,
     Some(&WORD_ADDC_NODE),
@@ -228970,12 +228970,12 @@ static WORD_ADD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADDT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDT_CHILDREN),
+static WORD_ADDT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -228995,12 +228995,12 @@ pub static WORD_ADDT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ADDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDR_CHILDREN),
+static WORD_ADDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ass"),
         dictgen::InsensitiveStr::Ascii("ees"),
@@ -229082,23 +229082,23 @@ pub static WORD_ADDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_ADDP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDP_CHILDREN),
+static WORD_ADDP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ress")],
     values: &[&["address"]],
     range: 4..=4,
 };
 
-static WORD_ADDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDO_CHILDREN),
+static WORD_ADDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nts"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -229116,23 +229116,23 @@ pub static WORD_ADDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ADDN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDN_CHILDREN),
+static WORD_ADDN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("os")],
     values: &[&["addons"]],
     range: 2..=2,
 };
 
-static WORD_ADDM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDM_CHILDREN),
+static WORD_ADDM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ission"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -229141,12 +229141,12 @@ pub static WORD_ADDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ADDJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDJ_CHILDREN),
+static WORD_ADDJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ust"),
         dictgen::InsensitiveStr::Ascii("usted"),
@@ -229157,12 +229157,12 @@ pub static WORD_ADDJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ADDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDI_CHILDREN),
+static WORD_ADDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cionally"),
@@ -229270,12 +229270,12 @@ pub static WORD_ADDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ADDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDE_CHILDREN),
+static WORD_ADDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dd"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -229305,12 +229305,12 @@ pub static WORD_ADDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ADDD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDD_CHILDREN),
+static WORD_ADDD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDD_CHILDREN),
     value: Some(&["add"]),
 };
 
-pub static WORD_ADDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -229332,23 +229332,23 @@ pub static WORD_ADDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ADDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDC_CHILDREN),
+static WORD_ADDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("its")],
     values: &[&["addicts"]],
     range: 3..=3,
 };
 
-static WORD_ADDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDA_CHILDREN),
+static WORD_ADDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("ptation"),
@@ -229368,12 +229368,12 @@ pub static WORD_ADDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ADB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADB_CHILDREN),
+static WORD_ADB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andon"),
         dictgen::InsensitiveStr::Ascii("omen"),
@@ -229384,12 +229384,12 @@ pub static WORD_ADB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ADA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADA_CHILDREN),
+static WORD_ADA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mently"),
@@ -229461,12 +229461,12 @@ pub static WORD_ADA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_AC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AC_CHILDREN),
+static WORD_AC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AC_CHILDREN),
     value: None,
 };
 
-static WORD_AC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACA_NODE),
     None,
     Some(&WORD_ACC_NODE),
@@ -229495,23 +229495,23 @@ static WORD_AC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACY_CHILDREN),
+static WORD_ACY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rlic")],
     values: &[&["acrylic"]],
     range: 4..=4,
 };
 
-static WORD_ACU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACU_CHILDREN),
+static WORD_ACU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -229573,12 +229573,12 @@ pub static WORD_ACU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ACT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACT_CHILDREN),
+static WORD_ACT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACT_CHILDREN),
     value: None,
 };
 
-static WORD_ACT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACTA_NODE),
     None,
     None,
@@ -229607,23 +229607,23 @@ static WORD_ACT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACTZ_NODE),
 ];
 
-static WORD_ACTZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTZ_CHILDREN),
+static WORD_ACTZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["actual"]],
     range: 2..=2,
 };
 
-static WORD_ACTV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTV_CHILDREN),
+static WORD_ACTV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -229634,12 +229634,12 @@ pub static WORD_ACTV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ACTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTU_CHILDREN),
+static WORD_ACTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aal"),
         dictgen::InsensitiveStr::Ascii("aally"),
@@ -229701,12 +229701,12 @@ pub static WORD_ACTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ACTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTR_CHILDREN),
+static WORD_ACTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esess"),
         dictgen::InsensitiveStr::Ascii("esss"),
@@ -229715,23 +229715,23 @@ pub static WORD_ACTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_ACTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTO_CHILDREN),
+static WORD_ACTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ve")],
     values: &[&["active"]],
     range: 2..=2,
 };
 
-static WORD_ACTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACTI_CHILDREN),
+static WORD_ACTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACTI_CHILDREN),
     value: None,
 };
 
-static WORD_ACTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACTIA_NODE),
     Some(&WORD_ACTIB_NODE),
     Some(&WORD_ACTIC_NODE),
@@ -229760,12 +229760,12 @@ static WORD_ACTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACTIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIV_CHILDREN),
+static WORD_ACTIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIV_CHILDREN),
     value: Some(&["active"]),
 };
 
-pub static WORD_ACTIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -229869,45 +229869,45 @@ pub static WORD_ACTIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ACTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIU_CHILDREN),
+static WORD_ACTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["actual"]],
     range: 2..=2,
 };
 
-static WORD_ACTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIT_CHILDREN),
+static WORD_ACTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ivies")],
     values: &[&["activities"]],
     range: 5..=5,
 };
 
-static WORD_ACTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIN_CHILDREN),
+static WORD_ACTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["active"]],
     range: 1..=1,
 };
 
-static WORD_ACTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIC_CHILDREN),
+static WORD_ACTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -229925,23 +229925,23 @@ pub static WORD_ACTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ACTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIB_CHILDREN),
+static WORD_ACTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ity")],
     values: &[&["activity"]],
     range: 3..=3,
 };
 
-static WORD_ACTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIA_CHILDREN),
+static WORD_ACTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -229969,12 +229969,12 @@ pub static WORD_ACTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ACTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTA_CHILDREN),
+static WORD_ACTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -229994,12 +229994,12 @@ pub static WORD_ACTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ACS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACS_CHILDREN),
+static WORD_ACS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ended"),
         dictgen::InsensitiveStr::Ascii("ending"),
@@ -230023,12 +230023,12 @@ pub static WORD_ACS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ACR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACR_CHILDREN),
+static WORD_ACR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("lyic"),
@@ -230064,12 +230064,12 @@ pub static WORD_ACR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ACQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACQ_CHILDREN),
+static WORD_ACQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("auinted"),
         dictgen::InsensitiveStr::Ascii("uaintace"),
@@ -230163,12 +230163,12 @@ pub static WORD_ACQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ACO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACO_CHILDREN),
+static WORD_ACO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cunt"),
         dictgen::InsensitiveStr::Ascii("mmodate"),
@@ -230248,12 +230248,12 @@ pub static WORD_ACO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_ACN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACN_CHILDREN),
+static WORD_ACN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACN_CHILDREN),
     value: Some(&["can", "acne"]),
 };
 
-pub static WORD_ACN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edote"),
         dictgen::InsensitiveStr::Ascii("owledge"),
@@ -230262,23 +230262,23 @@ pub static WORD_ACN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_ACL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACL_CHILDREN),
+static WORD_ACL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hemist")],
     values: &[&["alchemist"]],
     range: 6..=6,
 };
 
-static WORD_ACK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACK_CHILDREN),
+static WORD_ACK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nodledgment"),
         dictgen::InsensitiveStr::Ascii("nodledgments"),
@@ -230390,12 +230390,12 @@ pub static WORD_ACK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=13,
 };
 
-static WORD_ACI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACI_CHILDREN),
+static WORD_ACI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACI_CHILDREN),
     value: Some(&["acpi"]),
 };
 
-pub static WORD_ACI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dent"),
         dictgen::InsensitiveStr::Ascii("dental"),
@@ -230445,12 +230445,12 @@ pub static WORD_ACI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ACH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACH_CHILDREN),
+static WORD_ACH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eevable"),
         dictgen::InsensitiveStr::Ascii("eeve"),
@@ -230556,23 +230556,23 @@ pub static WORD_ACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ACF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACF_CHILDREN),
+static WORD_ACF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tually")],
     values: &[&["factually"]],
     range: 6..=6,
 };
 
-static WORD_ACE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACE_CHILDREN),
+static WORD_ACE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cess"),
         dictgen::InsensitiveStr::Ascii("damia"),
@@ -230636,12 +230636,12 @@ pub static WORD_ACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ACD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACD_CHILDREN),
+static WORD_ACD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ept"),
         dictgen::InsensitiveStr::Ascii("itionally"),
@@ -230650,12 +230650,12 @@ pub static WORD_ACD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ACC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACC_CHILDREN),
+static WORD_ACC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACC_CHILDREN),
     value: None,
 };
 
-static WORD_ACC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACCA_NODE),
     None,
     Some(&WORD_ACCC_NODE),
@@ -230684,12 +230684,12 @@ static WORD_ACC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACCU_CHILDREN),
+static WORD_ACCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACCU_CHILDREN),
     value: None,
 };
 
-static WORD_ACCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACCU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACCUA_NODE),
     None,
     None,
@@ -230718,23 +230718,23 @@ static WORD_ACCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACCUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUT_CHILDREN),
+static WORD_ACCUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["acute"]],
     range: 1..=1,
 };
 
-static WORD_ACCUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUS_CHILDREN),
+static WORD_ACCUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ating"),
         dictgen::InsensitiveStr::Ascii("ato"),
@@ -230754,12 +230754,12 @@ pub static WORD_ACCUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ACCUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUR_CHILDREN),
+static WORD_ACCUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("accies"),
@@ -230801,12 +230801,12 @@ pub static WORD_ACCUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ACCUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUP_CHILDREN),
+static WORD_ACCUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -230815,23 +230815,23 @@ pub static WORD_ACCUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_ACCUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUN_CHILDREN),
+static WORD_ACCUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["account"]],
     range: 1..=1,
 };
 
-static WORD_ACCUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUM_CHILDREN),
+static WORD_ACCUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("alated"),
@@ -230907,12 +230907,12 @@ pub static WORD_ACCUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ACCUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUL_CHILDREN),
+static WORD_ACCUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("umate"),
         dictgen::InsensitiveStr::Ascii("umated"),
@@ -230928,12 +230928,12 @@ pub static WORD_ACCUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ACCUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUA_CHILDREN),
+static WORD_ACCUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lly"),
         dictgen::InsensitiveStr::Ascii("rcy"),
@@ -230951,12 +230951,12 @@ pub static WORD_ACCUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ACCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCT_CHILDREN),
+static WORD_ACCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ual"),
         dictgen::InsensitiveStr::Ascii("ually"),
@@ -230965,12 +230965,12 @@ pub static WORD_ACCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ACCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCS_CHILDREN),
+static WORD_ACCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -230981,12 +230981,12 @@ pub static WORD_ACCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ACCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCR_CHILDREN),
+static WORD_ACCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acy"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -231030,12 +231030,12 @@ pub static WORD_ACCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ACCQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCQ_CHILDREN),
+static WORD_ACCQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uainted"),
         dictgen::InsensitiveStr::Ascii("uire"),
@@ -231053,12 +231053,12 @@ pub static WORD_ACCQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ACCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCP_CHILDREN),
+static WORD_ACCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etable"),
@@ -231078,12 +231078,12 @@ pub static WORD_ACCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ACCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACCO_CHILDREN),
+static WORD_ACCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACCO_CHILDREN),
     value: None,
 };
 
-static WORD_ACCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_ACCOC_NODE),
@@ -231112,12 +231112,12 @@ static WORD_ACCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACCOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOU_CHILDREN),
+static WORD_ACCOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nd"),
@@ -231167,23 +231167,23 @@ pub static WORD_ACCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_ACCOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOS_CHILDREN),
+static WORD_ACCOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tumed")],
     values: &[&["accustomed"]],
     range: 5..=5,
 };
 
-static WORD_ACCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOR_CHILDREN),
+static WORD_ACCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dding"),
         dictgen::InsensitiveStr::Ascii("deon"),
@@ -231245,23 +231245,23 @@ pub static WORD_ACCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ACCOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOP_CHILDREN),
+static WORD_ACCOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("unt")],
     values: &[&["account"]],
     range: 3..=3,
 };
 
-static WORD_ACCOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOO_CHILDREN),
+static WORD_ACCOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rding"),
         dictgen::InsensitiveStr::Ascii("rdingly"),
@@ -231271,12 +231271,12 @@ pub static WORD_ACCOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ACCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCON_CHILDREN),
+static WORD_ACCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("plishment"),
@@ -231296,12 +231296,12 @@ pub static WORD_ACCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ACCOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOM_CHILDREN),
+static WORD_ACCOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adate"),
         dictgen::InsensitiveStr::Ascii("adated"),
@@ -231421,12 +231421,12 @@ pub static WORD_ACCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_ACCOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOI_CHILDREN),
+static WORD_ACCOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nting"),
         dictgen::InsensitiveStr::Ascii("rd"),
@@ -231436,12 +231436,12 @@ pub static WORD_ACCOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ACCOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOD_CHILDREN),
+static WORD_ACCOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ingly"),
@@ -231465,12 +231465,12 @@ pub static WORD_ACCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ACCOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOC_CHILDREN),
+static WORD_ACCOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -231490,23 +231490,23 @@ pub static WORD_ACCOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ACCM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCM_CHILDREN),
+static WORD_ACCM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ulate")],
     values: &[&["accumulate"]],
     range: 5..=5,
 };
 
-static WORD_ACCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCL_CHILDREN),
+static WORD_ACCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amied"),
         dictgen::InsensitiveStr::Ascii("erate"),
@@ -231530,12 +231530,12 @@ pub static WORD_ACCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ACCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCI_CHILDREN),
+static WORD_ACCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cently"),
         dictgen::InsensitiveStr::Ascii("dant"),
@@ -231605,12 +231605,12 @@ pub static WORD_ACCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ACCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCH_CHILDREN),
+static WORD_ACCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iev"),
         dictgen::InsensitiveStr::Ascii("ievable"),
@@ -231636,12 +231636,12 @@ pub static WORD_ACCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ACCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACCE_CHILDREN),
+static WORD_ACCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACCE_CHILDREN),
     value: None,
 };
 
-static WORD_ACCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACCE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_ACCEC_NODE),
@@ -231670,12 +231670,12 @@ static WORD_ACCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACCET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCET_CHILDREN),
+static WORD_ACCET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCET_CHILDREN),
     value: Some(&["accept"]),
 };
 
-pub static WORD_ACCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ps"),
@@ -231685,12 +231685,12 @@ pub static WORD_ACCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ACCES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCES_CHILDREN),
+static WORD_ACCES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCES_CHILDREN),
     value: Some(&["access"]),
 };
 
-pub static WORD_ACCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -231804,23 +231804,23 @@ pub static WORD_ACCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ACCER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCER_CHILDREN),
+static WORD_ACCER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCER_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("elate")],
     values: &[&["accelerated"]],
     range: 5..=5,
 };
 
-static WORD_ACCEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEP_CHILDREN),
+static WORD_ACCEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atble"),
         dictgen::InsensitiveStr::Ascii("ect"),
@@ -231858,23 +231858,23 @@ pub static WORD_ACCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ACCEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEO_CHILDREN),
+static WORD_ACCEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["accept"]],
     range: 1..=1,
 };
 
-static WORD_ACCEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEN_CHILDREN),
+static WORD_ACCEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -231883,12 +231883,12 @@ pub static WORD_ACCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ACCEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEL_CHILDREN),
+static WORD_ACCEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("arated"),
@@ -231976,12 +231976,12 @@ pub static WORD_ACCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_ACCEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEE_CHILDREN),
+static WORD_ACCEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("ss"),
@@ -231990,23 +231990,23 @@ pub static WORD_ACCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_ACCED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCED_CHILDREN),
+static WORD_ACCED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCED_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("entally")],
     values: &[&["accidentally"]],
     range: 7..=7,
 };
 
-static WORD_ACCEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEC_CHILDREN),
+static WORD_ACCEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -232016,23 +232016,23 @@ pub static WORD_ACCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ACCD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCD_CHILDREN),
+static WORD_ACCD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iently")],
     values: &[&["accidently"]],
     range: 6..=6,
 };
 
-static WORD_ACCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCC_CHILDREN),
+static WORD_ACCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ept"),
         dictgen::InsensitiveStr::Ascii("eptable"),
@@ -232098,12 +232098,12 @@ pub static WORD_ACCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_ACCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCA_CHILDREN),
+static WORD_ACCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("demic"),
         dictgen::InsensitiveStr::Ascii("demy"),
@@ -232123,12 +232123,12 @@ pub static WORD_ACCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ACA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACA_CHILDREN),
+static WORD_ACA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("damy"),
         dictgen::InsensitiveStr::Ascii("demcially"),
@@ -232162,12 +232162,12 @@ pub static WORD_ACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_AB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AB_CHILDREN),
+static WORD_AB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AB_CHILDREN),
     value: None,
 };
 
-static WORD_AB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ABA_NODE),
     Some(&WORD_ABB_NODE),
     Some(&WORD_ABC_NODE),
@@ -232196,23 +232196,23 @@ static WORD_AB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ABY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABY_CHILDREN),
+static WORD_ABY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("msal")],
     values: &[&["abysmal"]],
     range: 4..=4,
 };
 
-static WORD_ABV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABV_CHILDREN),
+static WORD_ABV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailable"),
         dictgen::InsensitiveStr::Ascii("ious"),
@@ -232221,12 +232221,12 @@ pub static WORD_ABV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_ABU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABU_CHILDREN),
+static WORD_ABU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dance"),
         dictgen::InsensitiveStr::Ascii("dances"),
@@ -232268,12 +232268,12 @@ pub static WORD_ABU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ABT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABT_CHILDREN),
+static WORD_ABT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ract"),
         dictgen::InsensitiveStr::Ascii("racted"),
@@ -232301,12 +232301,12 @@ pub static WORD_ABT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_ABS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ABS_CHILDREN),
+static WORD_ABS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ABS_CHILDREN),
     value: None,
 };
 
-static WORD_ABS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ABS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ABSA_NODE),
     None,
     Some(&WORD_ABSC_NODE),
@@ -232335,23 +232335,23 @@ static WORD_ABS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ABSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSY_CHILDREN),
+static WORD_ABSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mal")],
     values: &[&["abysmal"]],
     range: 3..=3,
 };
 
-static WORD_ABSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSU_CHILDREN),
+static WORD_ABSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("lute"),
@@ -232371,12 +232371,12 @@ pub static WORD_ABSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ABST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABST_CHILDREN),
+static WORD_ABST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABST_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -232486,12 +232486,12 @@ pub static WORD_ABST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ABSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSR_CHILDREN),
+static WORD_ABSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("obed"),
         dictgen::InsensitiveStr::Ascii("obs"),
@@ -232500,12 +232500,12 @@ pub static WORD_ABSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ABSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ABSO_CHILDREN),
+static WORD_ABSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ABSO_CHILDREN),
     value: None,
 };
 
-static WORD_ABSO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ABSO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -232534,23 +232534,23 @@ static WORD_ABSO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ABSOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOV_CHILDREN),
+static WORD_ABSOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["absolve"]],
     range: 2..=2,
 };
 
-static WORD_ABSOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOU_CHILDREN),
+static WORD_ABSOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("ldly"),
@@ -232592,12 +232592,12 @@ pub static WORD_ABSOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ABSOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOR_CHILDREN),
+static WORD_ABSOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bant"),
         dictgen::InsensitiveStr::Ascii("bes"),
@@ -232617,23 +232617,23 @@ pub static WORD_ABSOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ABSOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOP_CHILDREN),
+static WORD_ABSOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rtion")],
     values: &[&["absorption"]],
     range: 5..=5,
 };
 
-static WORD_ABSOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOO_CHILDREN),
+static WORD_ABSOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lute"),
         dictgen::InsensitiveStr::Ascii("lutely"),
@@ -232642,12 +232642,12 @@ pub static WORD_ABSOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ABSOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOL_CHILDREN),
+static WORD_ABSOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ately"),
@@ -232751,12 +232751,12 @@ pub static WORD_ABSOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ABSOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOD_CHILDREN),
+static WORD_ABSOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efly"),
         dictgen::InsensitiveStr::Ascii("eflyly"),
@@ -232765,23 +232765,23 @@ pub static WORD_ABSOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ABSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSL_CHILDREN),
+static WORD_ABSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("outes")],
     values: &[&["absolutes"]],
     range: 5..=5,
 };
 
-static WORD_ABSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSI_CHILDREN),
+static WORD_ABSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntence"),
         dictgen::InsensitiveStr::Ascii("tnence"),
@@ -232790,12 +232790,12 @@ pub static WORD_ABSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_ABSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSE_CHILDREN),
+static WORD_ABSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("lutely"),
@@ -232815,12 +232815,12 @@ pub static WORD_ABSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ABSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSC_CHILDREN),
+static WORD_ABSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ound"),
@@ -232829,12 +232829,12 @@ pub static WORD_ABSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ABSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSA_CHILDREN),
+static WORD_ABSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("il"),
         dictgen::InsensitiveStr::Ascii("iling"),
@@ -232844,12 +232844,12 @@ pub static WORD_ABSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ABR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABR_CHILDREN),
+static WORD_ABR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eviate"),
         dictgen::InsensitiveStr::Ascii("eviated"),
@@ -232889,23 +232889,23 @@ pub static WORD_ABR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ABP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABP_CHILDREN),
+static WORD_ABP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ut")],
     values: &[&["about"]],
     range: 2..=2,
 };
 
-static WORD_ABO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABO_CHILDREN),
+static WORD_ABO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("dmen"),
@@ -233025,12 +233025,12 @@ pub static WORD_ABO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_ABN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABN_CHILDREN),
+static WORD_ABN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("oramlly"),
@@ -233052,12 +233052,12 @@ pub static WORD_ABN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ABL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABL_CHILDREN),
+static WORD_ABL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABL_CHILDREN),
     value: Some(&["able"]),
 };
 
-pub static WORD_ABL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iity"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -233075,23 +233075,23 @@ pub static WORD_ABL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ABJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABJ_CHILDREN),
+static WORD_ABJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ects")],
     values: &[&["objects"]],
     range: 4..=4,
 };
 
-static WORD_ABI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABI_CHILDREN),
+static WORD_ABI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gious"),
         dictgen::InsensitiveStr::Ascii("guity"),
@@ -233133,23 +233133,23 @@ pub static WORD_ABI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ABE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABE_CHILDREN),
+static WORD_ABE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ration")],
     values: &[&["aberration"]],
     range: 6..=6,
 };
 
-static WORD_ABD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABD_CHILDREN),
+static WORD_ABD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABD_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ABD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ominable"),
         dictgen::InsensitiveStr::Ascii("omine"),
@@ -233160,23 +233160,23 @@ pub static WORD_ABD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_ABC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABC_CHILDREN),
+static WORD_ABC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["back"]],
     range: 1..=1,
 };
 
-static WORD_ABB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABB_CHILDREN),
+static WORD_ABB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("breviated"),
         dictgen::InsensitiveStr::Ascii("eration"),
@@ -233242,12 +233242,12 @@ pub static WORD_ABB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_ABA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABA_CHILDREN),
+static WORD_ABA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("donded"),
         dictgen::InsensitiveStr::Ascii("donding"),
@@ -233291,12 +233291,12 @@ pub static WORD_ABA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_AA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AA_CHILDREN),
+static WORD_AA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccess"),
         dictgen::InsensitiveStr::Ascii("ccessibility"),
diff --git a/crates/typos-dict/src/word_codegen.rs b/crates/typos-dict/src/word_codegen.rs
index ad1b778..0a746e2 100644
--- a/crates/typos-dict/src/word_codegen.rs
+++ b/crates/typos-dict/src/word_codegen.rs
@@ -2,13 +2,13 @@
 #![allow(clippy::unreadable_literal)]
 #![allow(unreachable_pub)]
 
-pub static WORD: dictgen::DictTrie<&[&str]> = dictgen::DictTrie {
+pub static WORD: dictgen::Trie<&[&str]> = dictgen::Trie {
     root: &WORD_NODE,
     unicode: &WORD_UNICODE_TABLE,
     range: 2..=34,
 };
 
-pub static WORD_UNICODE_TABLE: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNICODE_TABLE: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Unicode("clockwíse"),
         dictgen::InsensitiveStr::Unicode("paínt"),
@@ -38,12 +38,12 @@ pub static WORD_UNICODE_TABLE: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=11,
 };
 
-static WORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHILDREN),
+static WORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHILDREN),
     value: None,
 };
 
-static WORD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_A_NODE),
     Some(&WORD_B_NODE),
     Some(&WORD_C_NODE),
@@ -72,12 +72,12 @@ static WORD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_Z_NODE),
 ];
 
-static WORD_Z_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_Z_CHILDREN),
+static WORD_Z_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_Z_CHILDREN),
     value: None,
 };
 
-static WORD_Z_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_Z_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ZA_NODE),
     None,
     None,
@@ -106,12 +106,12 @@ static WORD_Z_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ZY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZY_CHILDREN),
+static WORD_ZY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lophone"),
         dictgen::InsensitiveStr::Ascii("lophones"),
@@ -120,12 +120,12 @@ pub static WORD_ZY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_ZU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZU_CHILDREN),
+static WORD_ZU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cheenei"),
         dictgen::InsensitiveStr::Ascii("cheeni"),
@@ -147,12 +147,12 @@ pub static WORD_ZU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_ZO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZO_CHILDREN),
+static WORD_ZO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("briust"),
         dictgen::InsensitiveStr::Ascii("inism"),
@@ -198,23 +198,23 @@ pub static WORD_ZO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ZL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZL_CHILDREN),
+static WORD_ZL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ot")],
     values: &[&["slot"]],
     range: 2..=2,
 };
 
-static WORD_ZI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZI_CHILDREN),
+static WORD_ZI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mbabe"),
         dictgen::InsensitiveStr::Ascii("mbabew"),
@@ -262,12 +262,12 @@ pub static WORD_ZI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ZE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZE_CHILDREN),
+static WORD_ZE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alotes"),
         dictgen::InsensitiveStr::Ascii("aloths"),
@@ -307,12 +307,12 @@ pub static WORD_ZE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ZA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ZA_CHILDREN),
+static WORD_ZA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ZA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ZA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ZA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elots"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -321,12 +321,12 @@ pub static WORD_ZA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_Y_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_Y_CHILDREN),
+static WORD_Y_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_Y_CHILDREN),
     value: None,
 };
 
-static WORD_Y_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_Y_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_YA_NODE),
     None,
     None,
@@ -355,23 +355,23 @@ static WORD_Y_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_YY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YY_CHILDREN),
+static WORD_YY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YY_CHILDREN),
     value: None,
 };
 
-pub static WORD_YY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ou")],
     values: &[&["you"]],
     range: 2..=2,
 };
 
-static WORD_YU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YU_CHILDREN),
+static WORD_YU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YU_CHILDREN),
     value: None,
 };
 
-pub static WORD_YU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("foric"),
         dictgen::InsensitiveStr::Ascii("forically"),
@@ -393,12 +393,12 @@ pub static WORD_YU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_YT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YT_CHILDREN),
+static WORD_YT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YT_CHILDREN),
     value: None,
 };
 
-pub static WORD_YT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -408,34 +408,34 @@ pub static WORD_YT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_YS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YS_CHILDREN),
+static WORD_YS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YS_CHILDREN),
     value: None,
 };
 
-pub static WORD_YS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["yes", "use", "nyse"]],
     range: 1..=1,
 };
 
-static WORD_YR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YR_CHILDREN),
+static WORD_YR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YR_CHILDREN),
     value: None,
 };
 
-pub static WORD_YR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ea")],
     values: &[&["year"]],
     range: 2..=2,
 };
 
-static WORD_YP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YP_CHILDREN),
+static WORD_YP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YP_CHILDREN),
     value: None,
 };
 
-pub static WORD_YP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("ou"),
@@ -447,12 +447,12 @@ pub static WORD_YP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_YO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YO_CHILDREN),
+static WORD_YO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YO_CHILDREN),
     value: None,
 };
 
-pub static WORD_YO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esmite"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -560,23 +560,23 @@ pub static WORD_YO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_YM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YM_CHILDREN),
+static WORD_YM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YM_CHILDREN),
     value: None,
 };
 
-pub static WORD_YM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bols")],
     values: &[&["symbols"]],
     range: 4..=4,
 };
 
-static WORD_YI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YI_CHILDREN),
+static WORD_YI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YI_CHILDREN),
     value: None,
 };
 
-pub static WORD_YI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eldin"),
         dictgen::InsensitiveStr::Ascii("eleded"),
@@ -588,12 +588,12 @@ pub static WORD_YI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_YH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YH_CHILDREN),
+static WORD_YH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YH_CHILDREN),
     value: None,
 };
 
-pub static WORD_YH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -603,12 +603,12 @@ pub static WORD_YH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_YE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YE_CHILDREN),
+static WORD_YE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YE_CHILDREN),
     value: None,
 };
 
-pub static WORD_YE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arm"),
         dictgen::InsensitiveStr::Ascii("asr"),
@@ -660,12 +660,12 @@ pub static WORD_YE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_YA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_YA_CHILDREN),
+static WORD_YA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_YA_CHILDREN),
     value: None,
 };
 
-pub static WORD_YA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_YA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ching"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -685,12 +685,12 @@ pub static WORD_YA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_X_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_X_CHILDREN),
+static WORD_X_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_X_CHILDREN),
     value: None,
 };
 
-pub static WORD_X_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_X_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("describe"),
         dictgen::InsensitiveStr::Ascii("dpf"),
@@ -754,12 +754,12 @@ pub static WORD_X_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_W_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_W_CHILDREN),
+static WORD_W_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_W_CHILDREN),
     value: None,
 };
 
-static WORD_W_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_W_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WA_NODE),
     None,
     None,
@@ -788,12 +788,12 @@ static WORD_W_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WY_CHILDREN),
+static WORD_WY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("th"),
@@ -803,23 +803,23 @@ pub static WORD_WY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WW_CHILDREN),
+static WORD_WW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WW_CHILDREN),
     value: None,
 };
 
-pub static WORD_WW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ith")],
     values: &[&["with"]],
     range: 3..=3,
 };
 
-static WORD_WU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WU_CHILDREN),
+static WORD_WU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WU_CHILDREN),
     value: None,
 };
 
-pub static WORD_WU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("estions"),
         dictgen::InsensitiveStr::Ascii("ld"),
@@ -841,12 +841,12 @@ pub static WORD_WU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_WT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WT_CHILDREN),
+static WORD_WT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("iches"),
@@ -857,12 +857,12 @@ pub static WORD_WT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WS_CHILDREN),
+static WORD_WS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ee"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -871,12 +871,12 @@ pub static WORD_WS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_WR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WR_CHILDREN),
+static WORD_WR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WR_CHILDREN),
     value: None,
 };
 
-static WORD_WR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WRA_NODE),
     None,
     None,
@@ -905,12 +905,12 @@ static WORD_WR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRY_CHILDREN),
+static WORD_WRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("th"),
         dictgen::InsensitiveStr::Ascii("thed"),
@@ -921,12 +921,12 @@ pub static WORD_WRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_WRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRT_CHILDREN),
+static WORD_WRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eched"),
         dictgen::InsensitiveStr::Ascii("ie"),
@@ -936,12 +936,12 @@ pub static WORD_WRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_WRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRO_CHILDREN),
+static WORD_WRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -983,23 +983,23 @@ pub static WORD_WRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRN_CHILDREN),
+static WORD_WRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("agler")],
     values: &[&["wrangler"]],
     range: 5..=5,
 };
 
-static WORD_WRK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRK_CHILDREN),
+static WORD_WRK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRK_CHILDREN),
     value: Some(&["work"]),
 };
 
-pub static WORD_WRK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("load"),
         dictgen::InsensitiveStr::Ascii("loads"),
@@ -1008,12 +1008,12 @@ pub static WORD_WRK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_WRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRI_CHILDREN),
+static WORD_WRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("tebufer"),
@@ -1063,12 +1063,12 @@ pub static WORD_WRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_WRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRE_CHILDREN),
+static WORD_WRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckign"),
         dictgen::InsensitiveStr::Ascii("cthed"),
@@ -1102,12 +1102,12 @@ pub static WORD_WRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_WRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WRA_CHILDREN),
+static WORD_WRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("app"),
         dictgen::InsensitiveStr::Ascii("apped"),
@@ -1157,34 +1157,34 @@ pub static WORD_WRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_WQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WQ_CHILDREN),
+static WORD_WQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_WQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["was"]],
     range: 1..=1,
 };
 
-static WORD_WP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WP_CHILDREN),
+static WORD_WP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uld")],
     values: &[&["would"]],
     range: 3..=3,
 };
 
-static WORD_WO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WO_CHILDREN),
+static WORD_WO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WO_CHILDREN),
     value: None,
 };
 
-static WORD_WO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WOA_NODE),
     None,
     None,
@@ -1213,12 +1213,12 @@ static WORD_WO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOU_CHILDREN),
+static WORD_WOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOU_CHILDREN),
     value: Some(&["would"]),
 };
 
-pub static WORD_WOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dl"),
@@ -1258,12 +1258,12 @@ pub static WORD_WOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_WOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOT_CHILDREN),
+static WORD_WOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hout"),
@@ -1283,12 +1283,12 @@ pub static WORD_WOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WOR_CHILDREN),
+static WORD_WOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WOR_CHILDREN),
     value: None,
 };
 
-static WORD_WOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WORA_NODE),
     Some(&WORD_WORB_NODE),
     Some(&WORD_WORC_NODE),
@@ -1317,12 +1317,12 @@ static WORD_WOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORT_CHILDREN),
+static WORD_WORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("helss"),
@@ -1338,12 +1338,12 @@ pub static WORD_WORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_WORS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORS_CHILDREN),
+static WORD_WORS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORS_CHILDREN),
     value: Some(&["wars", "was", "works", "worse", "worst"]),
 };
 
-pub static WORD_WORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("hippig"),
@@ -1367,12 +1367,12 @@ pub static WORD_WORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_WORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORR_CHILDREN),
+static WORD_WORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -1381,12 +1381,12 @@ pub static WORD_WORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_WORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORN_CHILDREN),
+static WORD_WORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -1396,23 +1396,23 @@ pub static WORD_WORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_WORM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORM_CHILDREN),
+static WORD_WORM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORM_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arounds")],
     values: &[&["workarounds"]],
     range: 7..=7,
 };
 
-static WORD_WORL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORL_CHILDREN),
+static WORD_WORL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORL_CHILDREN),
     value: Some(&["world"]),
 };
 
-pub static WORD_WORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("divew"),
         dictgen::InsensitiveStr::Ascii("dveiw"),
@@ -1430,12 +1430,12 @@ pub static WORD_WORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_WORK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WORK_CHILDREN),
+static WORD_WORK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WORK_CHILDREN),
     value: None,
 };
 
-static WORD_WORK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WORK_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WORKA_NODE),
     Some(&WORD_WORKB_NODE),
     None,
@@ -1464,23 +1464,23 @@ static WORD_WORK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WORKW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKW_CHILDREN),
+static WORD_WORKW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKW_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("round")],
     values: &[&["workaround"]],
     range: 5..=5,
 };
 
-static WORD_WORKS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKS_CHILDREN),
+static WORD_WORKS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("apce"),
@@ -1520,12 +1520,12 @@ pub static WORD_WORKS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_WORKR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKR_CHILDREN),
+static WORD_WORKR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ound"),
         dictgen::InsensitiveStr::Ascii("ounds"),
@@ -1534,12 +1534,12 @@ pub static WORD_WORKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_WORKP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKP_CHILDREN),
+static WORD_WORKP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("sace"),
@@ -1549,12 +1549,12 @@ pub static WORD_WORKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_WORKL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKL_CHILDREN),
+static WORD_WORKL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fow"),
         dictgen::InsensitiveStr::Ascii("fows"),
@@ -1564,12 +1564,12 @@ pub static WORD_WORKL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_WORKI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKI_CHILDREN),
+static WORD_WORKI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gn"),
@@ -1587,12 +1587,12 @@ pub static WORD_WORKI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_WORKF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKF_CHILDREN),
+static WORD_WORKF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKF_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("around"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -1610,12 +1610,12 @@ pub static WORD_WORKF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_WORKE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKE_CHILDREN),
+static WORD_WORKE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKE_CHILDREN),
     value: Some(&["work", "worked", "works"]),
 };
 
-pub static WORD_WORKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nch"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -1624,23 +1624,23 @@ pub static WORD_WORKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_WORKD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKD_CHILDREN),
+static WORD_WORKD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKD_CHILDREN),
     value: Some(&["worked", "works"]),
 };
 
-pub static WORD_WORKD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pace")],
     values: &[&["workspace"]],
     range: 4..=4,
 };
 
-static WORD_WORKB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKB_CHILDREN),
+static WORD_WORKB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKB_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anch"),
         dictgen::InsensitiveStr::Ascii("anches"),
@@ -1668,12 +1668,12 @@ pub static WORD_WORKB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_WORKA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORKA_CHILDREN),
+static WORD_WORKA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORKA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORKA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orund"),
         dictgen::InsensitiveStr::Ascii("orunds"),
@@ -1727,23 +1727,23 @@ pub static WORD_WORKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_WORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORI_CHILDREN),
+static WORD_WORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["working"]],
     range: 2..=2,
 };
 
-static WORD_WORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORH_CHILDREN),
+static WORD_WORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("siping"),
         dictgen::InsensitiveStr::Ascii("sipping"),
@@ -1759,12 +1759,12 @@ pub static WORD_WORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_WORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORF_CHILDREN),
+static WORD_WORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("klow"),
         dictgen::InsensitiveStr::Ascii("klows"),
@@ -1775,12 +1775,12 @@ pub static WORD_WORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_WORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORD_CHILDREN),
+static WORD_WORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lview"),
@@ -1798,23 +1798,23 @@ pub static WORD_WORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_WORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORC_CHILDREN),
+static WORD_WORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hester")],
     values: &[&["worcester"]],
     range: 6..=6,
 };
 
-static WORD_WORB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORB_CHILDREN),
+static WORD_WORB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORB_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ench"),
         dictgen::InsensitiveStr::Ascii("enches"),
@@ -1823,12 +1823,12 @@ pub static WORD_WORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_WORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WORA_CHILDREN),
+static WORD_WORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("round"),
         dictgen::InsensitiveStr::Ascii("rounds"),
@@ -1837,12 +1837,12 @@ pub static WORD_WORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_WOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOO_CHILDREN),
+static WORD_WOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dowrking"),
         dictgen::InsensitiveStr::Ascii("dworkign"),
@@ -1852,12 +1852,12 @@ pub static WORD_WOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_WON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WON_CHILDREN),
+static WORD_WON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WON_CHILDREN),
     value: None,
 };
 
-pub static WORD_WON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("deful"),
@@ -1893,23 +1893,23 @@ pub static WORD_WON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_WOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOM_CHILDREN),
+static WORD_WOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ens")],
     values: &[&["women"]],
     range: 3..=3,
 };
 
-static WORD_WOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOL_CHILDREN),
+static WORD_WOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ffram"),
         dictgen::InsensitiveStr::Ascii("low"),
@@ -1933,12 +1933,12 @@ pub static WORD_WOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_WOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOK_CHILDREN),
+static WORD_WOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ring"),
@@ -1949,12 +1949,12 @@ pub static WORD_WOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOI_CHILDREN),
+static WORD_WOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -1966,34 +1966,34 @@ pub static WORD_WOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_WOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOH_CHILDREN),
+static WORD_WOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOH_CHILDREN),
     value: Some(&["who"]),
 };
 
-pub static WORD_WOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["whole"]],
     range: 2..=2,
 };
 
-static WORD_WOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WOA_CHILDREN),
+static WORD_WOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rkaround")],
     values: &[&["workaround"]],
     range: 8..=8,
 };
 
-static WORD_WN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WN_CHILDREN),
+static WORD_WN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -2019,23 +2019,23 @@ pub static WORD_WN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WM_CHILDREN),
+static WORD_WM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WM_CHILDREN),
     value: None,
 };
 
-pub static WORD_WM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pty")],
     values: &[&["empty"]],
     range: 3..=3,
 };
 
-static WORD_WL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WL_CHILDREN),
+static WORD_WL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acott"),
         dictgen::InsensitiveStr::Ascii("aking"),
@@ -2046,23 +2046,23 @@ pub static WORD_WL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WJ_CHILDREN),
+static WORD_WJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_WJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("at")],
     values: &[&["what"]],
     range: 2..=2,
 };
 
-static WORD_WI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WI_CHILDREN),
+static WORD_WI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WI_CHILDREN),
     value: None,
 };
 
-static WORD_WI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WIA_NODE),
     None,
     Some(&WORD_WIC_NODE),
@@ -2091,23 +2091,23 @@ static WORD_WI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_WIZ_NODE),
 ];
 
-static WORD_WIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIZ_CHILDREN),
+static WORD_WIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("zard")],
     values: &[&["wizard"]],
     range: 4..=4,
 };
 
-static WORD_WIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIY_CHILDREN),
+static WORD_WIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hout"),
@@ -2117,23 +2117,23 @@ pub static WORD_WIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIU_CHILDREN),
+static WORD_WIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ll")],
     values: &[&["will"]],
     range: 2..=2,
 };
 
-static WORD_WIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WIT_CHILDREN),
+static WORD_WIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WIT_CHILDREN),
     value: None,
 };
 
-static WORD_WIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WIT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WITA_NODE),
     None,
     None,
@@ -2162,45 +2162,45 @@ static WORD_WIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WITT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITT_CHILDREN),
+static WORD_WITT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["with"]],
     range: 1..=1,
 };
 
-static WORD_WITR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITR_CHILDREN),
+static WORD_WITR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["with"]],
     range: 1..=1,
 };
 
-static WORD_WITO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITO_CHILDREN),
+static WORD_WITO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ut")],
     values: &[&["without"]],
     range: 2..=2,
 };
 
-static WORD_WITN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITN_CHILDREN),
+static WORD_WITN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITN_CHILDREN),
     value: Some(&["with"]),
 };
 
-pub static WORD_WITN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esess"),
         dictgen::InsensitiveStr::Ascii("esss"),
@@ -2216,34 +2216,34 @@ pub static WORD_WITN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_WITK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITK_CHILDREN),
+static WORD_WITK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITK_CHILDREN),
     value: Some(&["with"]),
 };
 
-pub static WORD_WITK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_WITI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITI_CHILDREN),
+static WORD_WITI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("n")],
     values: &[&["within"]],
     range: 1..=1,
 };
 
-static WORD_WITH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITH_CHILDREN),
+static WORD_WITH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -2355,23 +2355,23 @@ pub static WORD_WITH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_WITE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITE_CHILDREN),
+static WORD_WITE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITE_CHILDREN),
     value: Some(&["write", "white"]),
 };
 
-pub static WORD_WITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_WITD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITD_CHILDREN),
+static WORD_WITD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITD_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hs"),
@@ -2382,23 +2382,23 @@ pub static WORD_WITD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_WITA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WITA_CHILDREN),
+static WORD_WITA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WITA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WITA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WITA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ble")],
     values: &[&["writeable"]],
     range: 3..=3,
 };
 
-static WORD_WIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIS_CHILDREN),
+static WORD_WIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cle"),
         dictgen::InsensitiveStr::Ascii("cled"),
@@ -2448,12 +2448,12 @@ pub static WORD_WIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_WIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIR_CHILDREN),
+static WORD_WIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("edest"),
@@ -2495,34 +2495,34 @@ pub static WORD_WIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_WIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIP_CHILDREN),
+static WORD_WIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oing")],
     values: &[&["wiping"]],
     range: 4..=4,
 };
 
-static WORD_WIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIO_CHILDREN),
+static WORD_WIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("th")],
     values: &[&["with"]],
     range: 2..=2,
 };
 
-static WORD_WIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIN_CHILDREN),
+static WORD_WIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cheseter"),
         dictgen::InsensitiveStr::Ascii("chestor"),
@@ -2594,12 +2594,12 @@ pub static WORD_WIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIM_CHILDREN),
+static WORD_WIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("men"),
         dictgen::InsensitiveStr::Ascii("menly"),
@@ -2609,12 +2609,12 @@ pub static WORD_WIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_WIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIL_CHILDREN),
+static WORD_WIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIL_CHILDREN),
     value: Some(&["will", "well"]),
 };
 
-pub static WORD_WIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("card"),
         dictgen::InsensitiveStr::Ascii("cards"),
@@ -2652,12 +2652,12 @@ pub static WORD_WIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIK_CHILDREN),
+static WORD_WIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ileakers"),
         dictgen::InsensitiveStr::Ascii("ileakes"),
@@ -2667,12 +2667,12 @@ pub static WORD_WIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_WII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WII_CHILDREN),
+static WORD_WII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WII_CHILDREN),
     value: None,
 };
 
-pub static WORD_WII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -2682,12 +2682,12 @@ pub static WORD_WII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_WIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIH_CHILDREN),
+static WORD_WIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIH_CHILDREN),
     value: Some(&["with"]),
 };
 
-pub static WORD_WIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ich"),
@@ -2711,12 +2711,12 @@ pub static WORD_WIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIG_CHILDREN),
+static WORD_WIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("det"),
         dictgen::InsensitiveStr::Ascii("dets"),
@@ -2732,12 +2732,12 @@ pub static WORD_WIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_WIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIE_CHILDREN),
+static WORD_WIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("ghed"),
@@ -2769,12 +2769,12 @@ pub static WORD_WIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_WID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WID_CHILDREN),
+static WORD_WID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WID_CHILDREN),
     value: None,
 };
 
-pub static WORD_WID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("epsread"),
@@ -2820,12 +2820,12 @@ pub static WORD_WID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_WIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIC_CHILDREN),
+static WORD_WIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -2834,12 +2834,12 @@ pub static WORD_WIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=1,
 };
 
-static WORD_WIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WIA_CHILDREN),
+static WORD_WIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ters"),
@@ -2850,12 +2850,12 @@ pub static WORD_WIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WH_CHILDREN),
+static WORD_WH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WH_CHILDREN),
     value: None,
 };
 
-static WORD_WH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WHA_NODE),
     None,
     Some(&WORD_WHC_NODE),
@@ -2884,12 +2884,12 @@ static WORD_WH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHY_CHILDREN),
+static WORD_WHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("th"),
@@ -2899,23 +2899,23 @@ pub static WORD_WHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHU_CHILDREN),
+static WORD_WHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["while", "whole"]],
     range: 2..=2,
 };
 
-static WORD_WHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHT_CHILDREN),
+static WORD_WHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHT_CHILDREN),
     value: Some(&["what"]),
 };
 
-pub static WORD_WHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("her"),
@@ -2926,12 +2926,12 @@ pub static WORD_WHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WHS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHS_CHILDREN),
+static WORD_WHS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iper"),
         dictgen::InsensitiveStr::Ascii("ipered"),
@@ -2942,12 +2942,12 @@ pub static WORD_WHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_WHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHR_CHILDREN),
+static WORD_WHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ilwind"),
@@ -2956,12 +2956,12 @@ pub static WORD_WHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHO_CHILDREN),
+static WORD_WHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -2999,23 +2999,23 @@ pub static WORD_WHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_WHN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHN_CHILDREN),
+static WORD_WHN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHN_CHILDREN),
     value: Some(&["when"]),
 };
 
-pub static WORD_WHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["when"]],
     range: 1..=1,
 };
 
-static WORD_WHL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHL_CHILDREN),
+static WORD_WHL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -3025,12 +3025,12 @@ pub static WORD_WHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_WHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHI_CHILDREN),
+static WORD_WHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cg"),
@@ -3158,12 +3158,12 @@ pub static WORD_WHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_WHH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHH_CHILDREN),
+static WORD_WHH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eel"),
         dictgen::InsensitiveStr::Ascii("en"),
@@ -3172,12 +3172,12 @@ pub static WORD_WHH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_WHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHE_CHILDREN),
+static WORD_WHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHE_CHILDREN),
     value: Some(&["when", "we"]),
 };
 
-pub static WORD_WHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ater"),
         dictgen::InsensitiveStr::Ascii("ather"),
@@ -3237,12 +3237,12 @@ pub static WORD_WHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_WHC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHC_CHILDREN),
+static WORD_WHC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("ich"),
@@ -3252,12 +3252,12 @@ pub static WORD_WHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_WHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WHA_CHILDREN),
+static WORD_WHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WHA_CHILDREN),
     value: Some(&["what"]),
 };
 
-pub static WORD_WHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WHA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("eton"),
@@ -3297,12 +3297,12 @@ pub static WORD_WHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WE_CHILDREN),
+static WORD_WE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WE_CHILDREN),
     value: None,
 };
 
-static WORD_WE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WEA_NODE),
     Some(&WORD_WEB_NODE),
     None,
@@ -3331,12 +3331,12 @@ static WORD_WE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_WEZ_NODE),
 ];
 
-static WORD_WEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEZ_CHILDREN),
+static WORD_WEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("zal"),
         dictgen::InsensitiveStr::Ascii("zals"),
@@ -3345,34 +3345,34 @@ pub static WORD_WEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_WEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEW_CHILDREN),
+static WORD_WEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEW_CHILDREN),
     value: Some(&["we"]),
 };
 
-pub static WORD_WEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_WET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WET_CHILDREN),
+static WORD_WET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WET_CHILDREN),
     value: None,
 };
 
-pub static WORD_WET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("her")],
     values: &[&["weather", "whether"]],
     range: 3..=3,
 };
 
-static WORD_WES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WES_CHILDREN),
+static WORD_WES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WES_CHILDREN),
     value: None,
 };
 
-pub static WORD_WES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bite"),
         dictgen::InsensitiveStr::Ascii("bites"),
@@ -3416,12 +3416,12 @@ pub static WORD_WES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_WER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WER_CHILDREN),
+static WORD_WER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WER_CHILDREN),
     value: None,
 };
 
-pub static WORD_WER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eabouts"),
         dictgen::InsensitiveStr::Ascii("eas"),
@@ -3451,12 +3451,12 @@ pub static WORD_WER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_WEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEP_CHILDREN),
+static WORD_WEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bage"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -3474,12 +3474,12 @@ pub static WORD_WEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_WEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEN_CHILDREN),
+static WORD_WEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("desday"),
         dictgen::InsensitiveStr::Ascii("desdays"),
@@ -3497,12 +3497,12 @@ pub static WORD_WEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_WEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEL_CHILDREN),
+static WORD_WEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEL_CHILDREN),
     value: Some(&["well"]),
 };
 
-pub static WORD_WEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("athier"),
         dictgen::InsensitiveStr::Ascii("athiest"),
@@ -3532,12 +3532,12 @@ pub static WORD_WEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEK_CHILDREN),
+static WORD_WEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("eend"),
@@ -3548,12 +3548,12 @@ pub static WORD_WEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEI_CHILDREN),
+static WORD_WEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghtened"),
         dictgen::InsensitiveStr::Ascii("ghtlfiting"),
@@ -3597,12 +3597,12 @@ pub static WORD_WEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_WEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEH_CHILDREN),
+static WORD_WEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ere"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -3613,23 +3613,23 @@ pub static WORD_WEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEG_CHILDREN),
+static WORD_WEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["wedge"]],
     range: 1..=1,
 };
 
-static WORD_WEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEE_CHILDREN),
+static WORD_WEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ek"),
         dictgen::InsensitiveStr::Ascii("ekend"),
@@ -3663,12 +3663,12 @@ pub static WORD_WEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WED_CHILDREN),
+static WORD_WED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WED_CHILDREN),
     value: None,
 };
 
-pub static WORD_WED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eged"),
         dictgen::InsensitiveStr::Ascii("ensday"),
@@ -3704,12 +3704,12 @@ pub static WORD_WED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_WEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEB_CHILDREN),
+static WORD_WEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("apge"),
@@ -3737,12 +3737,12 @@ pub static WORD_WEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_WEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WEA_CHILDREN),
+static WORD_WEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hter"),
         dictgen::InsensitiveStr::Ascii("hters"),
@@ -3782,23 +3782,23 @@ pub static WORD_WEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WD_CHILDREN),
+static WORD_WD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WD_CHILDREN),
     value: None,
 };
 
-pub static WORD_WD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("th")],
     values: &[&["width"]],
     range: 2..=2,
 };
 
-static WORD_WA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WA_CHILDREN),
+static WORD_WA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WA_CHILDREN),
     value: None,
 };
 
-static WORD_WA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WAA_NODE),
     None,
     Some(&WORD_WAC_NODE),
@@ -3827,12 +3827,12 @@ static WORD_WA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAY_CHILDREN),
+static WORD_WAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ferer"),
         dictgen::InsensitiveStr::Ascii("oint"),
@@ -3843,12 +3843,12 @@ pub static WORD_WAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_WAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAW_CHILDREN),
+static WORD_WAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -3858,12 +3858,12 @@ pub static WORD_WAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_WAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAV_CHILDREN),
+static WORD_WAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elegnth"),
         dictgen::InsensitiveStr::Ascii("elegnths"),
@@ -3891,12 +3891,12 @@ pub static WORD_WAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_WAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAT_CHILDREN),
+static WORD_WAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chdong"),
         dictgen::InsensitiveStr::Ascii("chemn"),
@@ -3954,12 +3954,12 @@ pub static WORD_WAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_WAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAS_CHILDREN),
+static WORD_WAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hignton"),
         dictgen::InsensitiveStr::Ascii("hingtion"),
@@ -3977,12 +3977,12 @@ pub static WORD_WAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_WAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_WAR_CHILDREN),
+static WORD_WAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_WAR_CHILDREN),
     value: None,
 };
 
-static WORD_WAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_WAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_WARA_NODE),
     None,
     Some(&WORD_WARC_NODE),
@@ -4011,34 +4011,34 @@ static WORD_WAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_WARW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARW_CHILDREN),
+static WORD_WARW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARW_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cik")],
     values: &[&["warwick"]],
     range: 3..=3,
 };
 
-static WORD_WARU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARU_CHILDREN),
+static WORD_WARU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARU_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mup")],
     values: &[&["warmup"]],
     range: 3..=3,
 };
 
-static WORD_WARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARR_CHILDREN),
+static WORD_WARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andyte"),
         dictgen::InsensitiveStr::Ascii("ante"),
@@ -4078,12 +4078,12 @@ pub static WORD_WARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_WARP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARP_CHILDREN),
+static WORD_WARP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ped"),
         dictgen::InsensitiveStr::Ascii("per"),
@@ -4107,12 +4107,12 @@ pub static WORD_WARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_WARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARN_CHILDREN),
+static WORD_WARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibg"),
         dictgen::InsensitiveStr::Ascii("ibgs"),
@@ -4178,34 +4178,34 @@ pub static WORD_WARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_WARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARL_CHILDREN),
+static WORD_WARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("king")],
     values: &[&["walking"]],
     range: 4..=4,
 };
 
-static WORD_WARK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARK_CHILDREN),
+static WORD_WARK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["works"]],
     range: 1..=1,
 };
 
-static WORD_WARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARI_CHILDREN),
+static WORD_WARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("ngs"),
@@ -4231,23 +4231,23 @@ pub static WORD_WARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_WARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARD_CHILDREN),
+static WORD_WARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("obe")],
     values: &[&["wardrobe"]],
     range: 3..=3,
 };
 
-static WORD_WARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARC_CHILDREN),
+static WORD_WARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arft"),
         dictgen::InsensitiveStr::Ascii("rat"),
@@ -4256,12 +4256,12 @@ pub static WORD_WARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_WARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WARA_CHILDREN),
+static WORD_WARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntee"),
         dictgen::InsensitiveStr::Ascii("nties"),
@@ -4271,23 +4271,23 @@ pub static WORD_WARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_WAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAP_CHILDREN),
+static WORD_WAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pers")],
     values: &[&["wrappers"]],
     range: 4..=4,
 };
 
-static WORD_WAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAN_CHILDREN),
+static WORD_WAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sts"),
         dictgen::InsensitiveStr::Ascii("td"),
@@ -4296,12 +4296,12 @@ pub static WORD_WAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_WAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAL_CHILDREN),
+static WORD_WAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kalbe"),
         dictgen::InsensitiveStr::Ascii("karound"),
@@ -4323,12 +4323,12 @@ pub static WORD_WAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_WAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAK_CHILDREN),
+static WORD_WAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eus"),
         dictgen::InsensitiveStr::Ascii("through"),
@@ -4344,12 +4344,12 @@ pub static WORD_WAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_WAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAI_CHILDREN),
+static WORD_WAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itng"),
         dictgen::InsensitiveStr::Ascii("nting"),
@@ -4373,12 +4373,12 @@ pub static WORD_WAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_WAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAH_CHILDREN),
+static WORD_WAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tever"),
@@ -4388,12 +4388,12 @@ pub static WORD_WAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_WAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAC_CHILDREN),
+static WORD_WAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hdog"),
         dictgen::InsensitiveStr::Ascii("lott"),
@@ -4403,23 +4403,23 @@ pub static WORD_WAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_WAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_WAA_CHILDREN),
+static WORD_WAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_WAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_WAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_WAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["was"]],
     range: 1..=1,
 };
 
-static WORD_V_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_V_CHILDREN),
+static WORD_V_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_V_CHILDREN),
     value: None,
 };
 
-static WORD_V_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_V_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VA_NODE),
     Some(&WORD_VB_NODE),
     None,
@@ -4448,12 +4448,12 @@ static WORD_V_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VY_CHILDREN),
+static WORD_VY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -4462,23 +4462,23 @@ pub static WORD_VY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_VV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VV_CHILDREN),
+static WORD_VV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VV_CHILDREN),
     value: None,
 };
 
-pub static WORD_VV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iew")],
     values: &[&["view"]],
     range: 3..=3,
 };
 
-static WORD_VU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VU_CHILDREN),
+static WORD_VU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VU_CHILDREN),
     value: None,
 };
 
-static WORD_VU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -4507,12 +4507,12 @@ static WORD_VU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VUR_CHILDREN),
+static WORD_VUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nerabilities"),
         dictgen::InsensitiveStr::Ascii("nerability"),
@@ -4521,12 +4521,12 @@ pub static WORD_VUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 10..=12,
 };
 
-static WORD_VUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VUN_CHILDREN),
+static WORD_VUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erabilities"),
         dictgen::InsensitiveStr::Ascii("erability"),
@@ -4552,12 +4552,12 @@ pub static WORD_VUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=12,
 };
 
-static WORD_VUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VUL_CHILDREN),
+static WORD_VUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VUL_CHILDREN),
     value: None,
 };
 
-static WORD_VUL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VUL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VULA_NODE),
     Some(&WORD_VULB_NODE),
     None,
@@ -4586,12 +4586,12 @@ static WORD_VUL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VULN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VULN_CHILDREN),
+static WORD_VULN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VULN_CHILDREN),
     value: None,
 };
 
-static WORD_VULN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VULN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VULNA_NODE),
     None,
     None,
@@ -4620,12 +4620,12 @@ static WORD_VULN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VULNU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULNU_CHILDREN),
+static WORD_VULNU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULNU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULNU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rabilities"),
         dictgen::InsensitiveStr::Ascii("rability"),
@@ -4635,12 +4635,12 @@ pub static WORD_VULNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_VULNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULNR_CHILDREN),
+static WORD_VULNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eabilities"),
         dictgen::InsensitiveStr::Ascii("eability"),
@@ -4649,12 +4649,12 @@ pub static WORD_VULNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_VULNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULNE_CHILDREN),
+static WORD_VULNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULNE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULNE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abilities"),
         dictgen::InsensitiveStr::Ascii("ability"),
@@ -4772,12 +4772,12 @@ pub static WORD_VULNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_VULND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULND_CHILDREN),
+static WORD_VULND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULND_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erabilities"),
         dictgen::InsensitiveStr::Ascii("erability"),
@@ -4786,12 +4786,12 @@ pub static WORD_VULND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=11,
 };
 
-static WORD_VULNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULNA_CHILDREN),
+static WORD_VULNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rabilities"),
         dictgen::InsensitiveStr::Ascii("rability"),
@@ -4801,12 +4801,12 @@ pub static WORD_VULNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_VULE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULE_CHILDREN),
+static WORD_VULE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nrability"),
         dictgen::InsensitiveStr::Ascii("rabilities"),
@@ -4834,12 +4834,12 @@ pub static WORD_VULE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_VULB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULB_CHILDREN),
+static WORD_VULB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earable"),
         dictgen::InsensitiveStr::Ascii("earabule"),
@@ -4919,12 +4919,12 @@ pub static WORD_VULB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=13,
 };
 
-static WORD_VULA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VULA_CHILDREN),
+static WORD_VULA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VULA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VULA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VULA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cn"),
         dictgen::InsensitiveStr::Ascii("kn"),
@@ -4933,12 +4933,12 @@ pub static WORD_VULA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=2,
 };
 
-static WORD_VR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VR_CHILDREN),
+static WORD_VR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eity"),
         dictgen::InsensitiveStr::Ascii("esion"),
@@ -4992,12 +4992,12 @@ pub static WORD_VR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_VO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VO_CHILDREN),
+static WORD_VO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VO_CHILDREN),
     value: None,
 };
 
-static WORD_VO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_VOC_NODE),
@@ -5026,12 +5026,12 @@ static WORD_VO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOY_CHILDREN),
+static WORD_VOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("our"),
         dictgen::InsensitiveStr::Ascii("ouristic"),
@@ -5047,23 +5047,23 @@ pub static WORD_VOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_VOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOX_CHILDREN),
+static WORD_VOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["voxels", "voxel"]],
     range: 2..=2,
 };
 
-static WORD_VOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOU_CHILDREN),
+static WORD_VOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("me"),
@@ -5072,45 +5072,45 @@ pub static WORD_VOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_VOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOT_CHILDREN),
+static WORD_VOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lage")],
     values: &[&["voltage"]],
     range: 4..=4,
 };
 
-static WORD_VON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VON_CHILDREN),
+static WORD_VON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VON_CHILDREN),
     value: None,
 };
 
-pub static WORD_VON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fig")],
     values: &[&["config"]],
     range: 3..=3,
 };
 
-static WORD_VOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOM_CHILDREN),
+static WORD_VOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itting")],
     values: &[&["vomiting"]],
     range: 6..=6,
 };
 
-static WORD_VOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOL_CHILDREN),
+static WORD_VOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atage"),
         dictgen::InsensitiveStr::Ascii("atages"),
@@ -5232,12 +5232,12 @@ pub static WORD_VOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_VOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOI_CHILDREN),
+static WORD_VOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cemal"),
         dictgen::InsensitiveStr::Ascii("f"),
@@ -5259,12 +5259,12 @@ pub static WORD_VOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_VOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VOC_CHILDREN),
+static WORD_VOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abluary"),
         dictgen::InsensitiveStr::Ascii("abularily"),
@@ -5282,12 +5282,12 @@ pub static WORD_VOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_VL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VL_CHILDREN),
+static WORD_VL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arge"),
         dictgen::InsensitiveStr::Ascii("aue"),
@@ -5309,12 +5309,12 @@ pub static WORD_VL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_VI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VI_CHILDREN),
+static WORD_VI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VI_CHILDREN),
     value: None,
 };
 
-static WORD_VI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VIA_NODE),
     Some(&WORD_VIB_NODE),
     Some(&WORD_VIC_NODE),
@@ -5343,12 +5343,12 @@ static WORD_VI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_VIZ_NODE),
 ];
 
-static WORD_VIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIZ_CHILDREN),
+static WORD_VIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ualisation"),
         dictgen::InsensitiveStr::Ascii("ualisations"),
@@ -5370,12 +5370,12 @@ pub static WORD_VIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=11,
 };
 
-static WORD_VIW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIW_CHILDREN),
+static WORD_VIW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIW_CHILDREN),
     value: Some(&["view"]),
 };
 
-pub static WORD_VIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -5395,12 +5395,12 @@ pub static WORD_VIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_VIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIU_CHILDREN),
+static WORD_VIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sally"),
         dictgen::InsensitiveStr::Ascii("sualisation"),
@@ -5409,12 +5409,12 @@ pub static WORD_VIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_VIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIT_CHILDREN),
+static WORD_VIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailty"),
         dictgen::InsensitiveStr::Ascii("aliy"),
@@ -5460,12 +5460,12 @@ pub static WORD_VIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_VIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VIS_CHILDREN),
+static WORD_VIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VIS_CHILDREN),
     value: None,
 };
 
-static WORD_VIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VIS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VISA_NODE),
     Some(&WORD_VISB_NODE),
     Some(&WORD_VISC_NODE),
@@ -5494,12 +5494,12 @@ static WORD_VIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VISU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISU_CHILDREN),
+static WORD_VISU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ab"),
         dictgen::InsensitiveStr::Ascii("abisation"),
@@ -5595,14 +5595,14 @@ pub static WORD_VISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_VIST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIST_CHILDREN),
+static WORD_VIST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIST_CHILDREN),
     value: Some(&[
         "visit", "fist", "gist", "list", "mist", "vast", "vest", "vista",
     ]),
 };
 
-pub static WORD_VIST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -5618,23 +5618,23 @@ pub static WORD_VIST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_VISS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISS_CHILDREN),
+static WORD_VISS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ible")],
     values: &[&["visible"]],
     range: 4..=4,
 };
 
-static WORD_VISI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISI_CHILDREN),
+static WORD_VISI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ably"),
@@ -5702,12 +5702,12 @@ pub static WORD_VISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_VISH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISH_CHILDREN),
+static WORD_VISH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISH_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eate"),
         dictgen::InsensitiveStr::Ascii("eation"),
@@ -5727,12 +5727,12 @@ pub static WORD_VISH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_VISE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISE_CHILDREN),
+static WORD_VISE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ral"),
         dictgen::InsensitiveStr::Ascii("rally"),
@@ -5742,23 +5742,23 @@ pub static WORD_VISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_VISC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISC_CHILDREN),
+static WORD_VISC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("real")],
     values: &[&["visceral"]],
     range: 4..=4,
 };
 
-static WORD_VISB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISB_CHILDREN),
+static WORD_VISB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ility"),
         dictgen::InsensitiveStr::Ascii("ily"),
@@ -5776,12 +5776,12 @@ pub static WORD_VISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_VISA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VISA_CHILDREN),
+static WORD_VISA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VISA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VISA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -5791,12 +5791,12 @@ pub static WORD_VISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_VIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIR_CHILDREN),
+static WORD_VIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alence"),
         dictgen::InsensitiveStr::Ascii("alently"),
@@ -5908,12 +5908,12 @@ pub static WORD_VIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_VIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIO_CHILDREN),
+static WORD_VIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alte"),
         dictgen::InsensitiveStr::Ascii("alting"),
@@ -5945,12 +5945,12 @@ pub static WORD_VIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_VIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIN_CHILDREN),
+static WORD_VIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cinity"),
         dictgen::InsensitiveStr::Ascii("dicitve"),
@@ -5980,12 +5980,12 @@ pub static WORD_VIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_VIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIL_CHILDREN),
+static WORD_VIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igant"),
         dictgen::InsensitiveStr::Ascii("igante"),
@@ -6019,12 +6019,12 @@ pub static WORD_VIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_VIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIK_CHILDREN),
+static WORD_VIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igns"),
         dictgen::InsensitiveStr::Ascii("ingos"),
@@ -6033,12 +6033,12 @@ pub static WORD_VIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_VIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIG_CHILDREN),
+static WORD_VIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eur"),
         dictgen::InsensitiveStr::Ascii("ilane"),
@@ -6070,12 +6070,12 @@ pub static WORD_VIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_VIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIE_CHILDREN),
+static WORD_VIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("do"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -6125,12 +6125,12 @@ pub static WORD_VIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=15,
 };
 
-static WORD_VID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VID_CHILDREN),
+static WORD_VID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VID_CHILDREN),
     value: None,
 };
 
-pub static WORD_VID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eogaem"),
         dictgen::InsensitiveStr::Ascii("eogaems"),
@@ -6158,12 +6158,12 @@ pub static WORD_VID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_VIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIC_CHILDREN),
+static WORD_VIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("intiy"),
         dictgen::InsensitiveStr::Ascii("itmized"),
@@ -6235,12 +6235,12 @@ pub static WORD_VIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_VIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIB_CHILDREN),
+static WORD_VIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ratao"),
         dictgen::InsensitiveStr::Ascii("ratie"),
@@ -6258,12 +6258,12 @@ pub static WORD_VIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_VIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VIA_CHILDREN),
+static WORD_VIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biliy"),
         dictgen::InsensitiveStr::Ascii("riable"),
@@ -6281,23 +6281,23 @@ pub static WORD_VIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_VH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VH_CHILDREN),
+static WORD_VH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VH_CHILDREN),
     value: None,
 };
 
-pub static WORD_VH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ild")],
     values: &[&["child"]],
     range: 3..=3,
 };
 
-static WORD_VE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VE_CHILDREN),
+static WORD_VE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VE_CHILDREN),
     value: None,
 };
 
-static WORD_VE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VEA_NODE),
     Some(&WORD_VEB_NODE),
     Some(&WORD_VEC_NODE),
@@ -6326,34 +6326,34 @@ static WORD_VE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEY_CHILDREN),
+static WORD_VEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEY_CHILDREN),
     value: Some(&["very"]),
 };
 
-pub static WORD_VEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["very"]],
     range: 1..=1,
 };
 
-static WORD_VEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEW_CHILDREN),
+static WORD_VEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEW_CHILDREN),
     value: Some(&["view"]),
 };
 
-pub static WORD_VEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iership")],
     values: &[&["viewership"]],
     range: 7..=7,
 };
 
-static WORD_VET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VET_CHILDREN),
+static WORD_VET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VET_CHILDREN),
     value: None,
 };
 
-pub static WORD_VET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ex"),
         dictgen::InsensitiveStr::Ascii("exes"),
@@ -6387,12 +6387,12 @@ pub static WORD_VET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_VES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VES_CHILDREN),
+static WORD_VES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VES_CHILDREN),
     value: None,
 };
 
-pub static WORD_VES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -6414,12 +6414,12 @@ pub static WORD_VES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_VER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VER_CHILDREN),
+static WORD_VER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VER_CHILDREN),
     value: None,
 };
 
-static WORD_VER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VERA_NODE),
     Some(&WORD_VERB_NODE),
     Some(&WORD_VERC_NODE),
@@ -6448,12 +6448,12 @@ static WORD_VER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERY_CHILDREN),
+static WORD_VERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fieng"),
         dictgen::InsensitiveStr::Ascii("fing"),
@@ -6481,23 +6481,23 @@ pub static WORD_VERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_VERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERU_CHILDREN),
+static WORD_VERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERU_CHILDREN),
     value: Some(&["very"]),
 };
 
-pub static WORD_VERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_VERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERT_CHILDREN),
+static WORD_VERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abim"),
         dictgen::InsensitiveStr::Ascii("abraes"),
@@ -6579,12 +6579,12 @@ pub static WORD_VERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_VERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERS_CHILDREN),
+static WORD_VERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alite"),
         dictgen::InsensitiveStr::Ascii("atality"),
@@ -6680,12 +6680,12 @@ pub static WORD_VERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_VERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERR_CHILDREN),
+static WORD_VERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -6695,12 +6695,12 @@ pub static WORD_VERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_VERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERN_CHILDREN),
+static WORD_VERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aculaire"),
         dictgen::InsensitiveStr::Ascii("dor"),
@@ -6716,12 +6716,12 @@ pub static WORD_VERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_VERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERM_CHILDREN),
+static WORD_VERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("uth"),
@@ -6730,23 +6730,23 @@ pub static WORD_VERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_VERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERL_CHILDREN),
+static WORD_VERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["very"]],
     range: 1..=1,
 };
 
-static WORD_VERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERI_CHILDREN),
+static WORD_VERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -6864,12 +6864,12 @@ pub static WORD_VERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_VERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERF_CHILDREN),
+static WORD_VERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("iciation"),
@@ -6915,12 +6915,12 @@ pub static WORD_VERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_VERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERE_CHILDREN),
+static WORD_VERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gated"),
         dictgen::InsensitiveStr::Ascii("igated"),
@@ -6938,12 +6938,12 @@ pub static WORD_VERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_VERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERC_CHILDREN),
+static WORD_VERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hew"),
         dictgen::InsensitiveStr::Ascii("hews"),
@@ -6954,12 +6954,12 @@ pub static WORD_VERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_VERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERB_CHILDREN),
+static WORD_VERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("aitm"),
@@ -6991,12 +6991,12 @@ pub static WORD_VERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_VERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VERA_CHILDREN),
+static WORD_VERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blly"),
         dictgen::InsensitiveStr::Ascii("gated"),
@@ -7006,12 +7006,12 @@ pub static WORD_VERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_VEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEN_CHILDREN),
+static WORD_VEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deta"),
         dictgen::InsensitiveStr::Ascii("dettta"),
@@ -7071,12 +7071,12 @@ pub static WORD_VEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_VEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEL_CHILDREN),
+static WORD_VEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antine"),
         dictgen::InsensitiveStr::Ascii("city"),
@@ -7096,12 +7096,12 @@ pub static WORD_VEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_VEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEK_CHILDREN),
+static WORD_VEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tor"),
         dictgen::InsensitiveStr::Ascii("tors"),
@@ -7110,12 +7110,12 @@ pub static WORD_VEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_VEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEI_CHILDREN),
+static WORD_VEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chles"),
         dictgen::InsensitiveStr::Ascii("cle"),
@@ -7155,12 +7155,12 @@ pub static WORD_VEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_VEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEH_CHILDREN),
+static WORD_VEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cile"),
         dictgen::InsensitiveStr::Ascii("ciles"),
@@ -7188,12 +7188,12 @@ pub static WORD_VEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_VEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEG_CHILDREN),
+static WORD_VEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anisim"),
         dictgen::InsensitiveStr::Ascii("ansim"),
@@ -7261,34 +7261,34 @@ pub static WORD_VEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_VEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEF_CHILDREN),
+static WORD_VEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iry")],
     values: &[&["verify"]],
     range: 3..=3,
 };
 
-static WORD_VED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VED_CHILDREN),
+static WORD_VED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VED_CHILDREN),
     value: None,
 };
 
-pub static WORD_VED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("io")],
     values: &[&["video"]],
     range: 2..=2,
 };
 
-static WORD_VEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEC_CHILDREN),
+static WORD_VEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hicle"),
         dictgen::InsensitiveStr::Ascii("hile"),
@@ -7332,23 +7332,23 @@ pub static WORD_VEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_VEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEB_CHILDREN),
+static WORD_VEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rose")],
     values: &[&["verbose"]],
     range: 4..=4,
 };
 
-static WORD_VEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VEA_CHILDREN),
+static WORD_VEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mant"),
         dictgen::InsensitiveStr::Ascii("mantly"),
@@ -7358,23 +7358,23 @@ pub static WORD_VEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_VB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VB_CHILDREN),
+static WORD_VB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("srcript")],
     values: &[&["vbscript"]],
     range: 7..=7,
 };
 
-static WORD_VA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VA_CHILDREN),
+static WORD_VA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VA_CHILDREN),
     value: None,
 };
 
-static WORD_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VAA_NODE),
     None,
     Some(&WORD_VAC_NODE),
@@ -7403,23 +7403,23 @@ static WORD_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAY_CHILDREN),
+static WORD_VAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lkrie")],
     values: &[&["valkyrie"]],
     range: 5..=5,
 };
 
-static WORD_VAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAW_CHILDREN),
+static WORD_VAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dville"),
         dictgen::InsensitiveStr::Ascii("dvillean"),
@@ -7429,12 +7429,12 @@ pub static WORD_VAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=8,
 };
 
-static WORD_VAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAV_CHILDREN),
+static WORD_VAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("le"),
@@ -7452,12 +7452,12 @@ pub static WORD_VAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_VAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAU_CHILDREN),
+static WORD_VAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -7485,12 +7485,12 @@ pub static WORD_VAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_VAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAT_CHILDREN),
+static WORD_VAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icaan"),
         dictgen::InsensitiveStr::Ascii("icina"),
@@ -7499,12 +7499,12 @@ pub static WORD_VAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_VAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAS_CHILDREN),
+static WORD_VAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAS_CHILDREN),
     value: Some(&["was"]),
 };
 
-pub static WORD_VAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("alls"),
@@ -7530,12 +7530,12 @@ pub static WORD_VAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_VAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VAR_CHILDREN),
+static WORD_VAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VAR_CHILDREN),
     value: None,
 };
 
-static WORD_VAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VARA_NODE),
     None,
     None,
@@ -7564,12 +7564,12 @@ static WORD_VAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VART_CHILDREN),
+static WORD_VART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VART_CHILDREN),
     value: Some(&["cart", "wart"]),
 };
 
-pub static WORD_VART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ex"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -7587,23 +7587,23 @@ pub static WORD_VART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_VARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARS_CHILDREN),
+static WORD_VARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tiy")],
     values: &[&["varsity"]],
     range: 3..=3,
 };
 
-static WORD_VARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARR_CHILDREN),
+static WORD_VARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iance"),
         dictgen::InsensitiveStr::Ascii("iances"),
@@ -7612,12 +7612,12 @@ pub static WORD_VARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_VARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARO_CHILDREN),
+static WORD_VARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ius"),
         dictgen::InsensitiveStr::Ascii("us"),
@@ -7627,12 +7627,12 @@ pub static WORD_VARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_VARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARN_CHILDREN),
+static WORD_VARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARN_CHILDREN),
     value: Some(&["warn"]),
 };
 
-pub static WORD_VARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -7643,12 +7643,12 @@ pub static WORD_VARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_VARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARM_CHILDREN),
+static WORD_VARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("its"),
@@ -7657,12 +7657,12 @@ pub static WORD_VARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_VARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VARI_CHILDREN),
+static WORD_VARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VARI_CHILDREN),
     value: None,
 };
 
-static WORD_VARI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VARI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VARIA_NODE),
     Some(&WORD_VARIB_NODE),
     None,
@@ -7691,12 +7691,12 @@ static WORD_VARI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VARIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIU_CHILDREN),
+static WORD_VARIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("os"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -7706,12 +7706,12 @@ pub static WORD_VARIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_VARIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIT_CHILDREN),
+static WORD_VARIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ey"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -7721,23 +7721,23 @@ pub static WORD_VARIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_VARIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIS_CHILDREN),
+static WORD_VARIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ty")],
     values: &[&["varsity"]],
     range: 2..=2,
 };
 
-static WORD_VARIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIN_CHILDREN),
+static WORD_VARIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ats"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -7746,12 +7746,12 @@ pub static WORD_VARIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_VARIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIL_CHILDREN),
+static WORD_VARIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ue"),
         dictgen::InsensitiveStr::Ascii("ues"),
@@ -7760,34 +7760,34 @@ pub static WORD_VARIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_VARII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARII_CHILDREN),
+static WORD_VARII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARII_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["varying"]],
     range: 2..=2,
 };
 
-static WORD_VARIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIG_CHILDREN),
+static WORD_VARIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ated")],
     values: &[&["variegated"]],
     range: 4..=4,
 };
 
-static WORD_VARIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIF_CHILDREN),
+static WORD_VARIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -7807,12 +7807,12 @@ pub static WORD_VARIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_VARIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIE_CHILDREN),
+static WORD_VARIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -7836,12 +7836,12 @@ pub static WORD_VARIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_VARIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIB_CHILDREN),
+static WORD_VARIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -7873,12 +7873,12 @@ pub static WORD_VARIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_VARIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARIA_CHILDREN),
+static WORD_VARIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bble"),
         dictgen::InsensitiveStr::Ascii("bbles"),
@@ -7950,12 +7950,12 @@ pub static WORD_VARIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_VARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARE_CHILDREN),
+static WORD_VARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gated"),
         dictgen::InsensitiveStr::Ascii("igated"),
@@ -7965,12 +7965,12 @@ pub static WORD_VARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_VARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VARA_CHILDREN),
+static WORD_VARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bles"),
@@ -8004,12 +8004,12 @@ pub static WORD_VARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_VAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAN_CHILDREN),
+static WORD_VAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adlism"),
         dictgen::InsensitiveStr::Ascii("dalisim"),
@@ -8035,12 +8035,12 @@ pub static WORD_VAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_VAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAM_CHILDREN),
+static WORD_VAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipres"),
         dictgen::InsensitiveStr::Ascii("piers"),
@@ -8051,12 +8051,12 @@ pub static WORD_VAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_VAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_VAL_CHILDREN),
+static WORD_VAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_VAL_CHILDREN),
     value: None,
 };
 
-static WORD_VAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_VAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_VALA_NODE),
     None,
     None,
@@ -8085,12 +8085,12 @@ static WORD_VAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_VALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALY_CHILDREN),
+static WORD_VALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALY_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("krie"),
@@ -8099,12 +8099,12 @@ pub static WORD_VALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_VALU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALU_CHILDREN),
+static WORD_VALU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALU_CHILDREN),
     value: Some(&["value"]),
 };
 
-pub static WORD_VALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("bale"),
@@ -8144,12 +8144,12 @@ pub static WORD_VALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_VALT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALT_CHILDREN),
+static WORD_VALT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALT_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -8158,23 +8158,23 @@ pub static WORD_VALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_VALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALS_CHILDREN),
+static WORD_VALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ues")],
     values: &[&["values"]],
     range: 3..=3,
 };
 
-static WORD_VALN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALN_CHILDREN),
+static WORD_VALN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALN_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecia"),
         dictgen::InsensitiveStr::Ascii("etines"),
@@ -8183,12 +8183,12 @@ pub static WORD_VALN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_VALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALL_CHILDREN),
+static WORD_VALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALL_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ayed"),
@@ -8222,12 +8222,12 @@ pub static WORD_VALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_VALK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALK_CHILDREN),
+static WORD_VALK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALK_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irye"),
         dictgen::InsensitiveStr::Ascii("iyre"),
@@ -8249,12 +8249,12 @@ pub static WORD_VALK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_VALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALI_CHILDREN),
+static WORD_VALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ator"),
@@ -8318,12 +8318,12 @@ pub static WORD_VALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_VALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALE_CHILDREN),
+static WORD_VALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nca"),
         dictgen::InsensitiveStr::Ascii("nica"),
@@ -8361,12 +8361,12 @@ pub static WORD_VALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_VALD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALD_CHILDREN),
+static WORD_VALD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALD_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -8376,23 +8376,23 @@ pub static WORD_VALD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_VALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VALA_CHILDREN),
+static WORD_VALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ilable")],
     values: &[&["available"]],
     range: 6..=6,
 };
 
-static WORD_VAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAK_CHILDREN),
+static WORD_VAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lyrie"),
         dictgen::InsensitiveStr::Ascii("ue"),
@@ -8403,12 +8403,12 @@ pub static WORD_VAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_VAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAI_CHILDREN),
+static WORD_VAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAI_CHILDREN),
     value: Some(&["via", "vie"]),
 };
 
-pub static WORD_VAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -8452,12 +8452,12 @@ pub static WORD_VAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_VAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAG_CHILDREN),
+static WORD_VAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euly"),
         dictgen::InsensitiveStr::Ascii("uaries"),
@@ -8468,12 +8468,12 @@ pub static WORD_VAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_VAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAE_CHILDREN),
+static WORD_VAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lue"),
         dictgen::InsensitiveStr::Ascii("lues"),
@@ -8482,12 +8482,12 @@ pub static WORD_VAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_VAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAC_CHILDREN),
+static WORD_VAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciante"),
         dictgen::InsensitiveStr::Ascii("ciantion"),
@@ -8565,23 +8565,23 @@ pub static WORD_VAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_VAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_VAA_CHILDREN),
+static WORD_VAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_VAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_VAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_VAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lues")],
     values: &[&["values"]],
     range: 4..=4,
 };
 
-static WORD_U_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_U_CHILDREN),
+static WORD_U_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_U_CHILDREN),
     value: None,
 };
 
-static WORD_U_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_U_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_UB_NODE),
     Some(&WORD_UC_NODE),
@@ -8610,23 +8610,23 @@ static WORD_U_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UY_CHILDREN),
+static WORD_UY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UY_CHILDREN),
     value: None,
 };
 
-pub static WORD_UY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ou")],
     values: &[&["you"]],
     range: 2..=2,
 };
 
-static WORD_UU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UU_CHILDREN),
+static WORD_UU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pload"),
         dictgen::InsensitiveStr::Ascii("pper"),
@@ -8635,12 +8635,12 @@ pub static WORD_UU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_UT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UT_CHILDREN),
+static WORD_UT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iilties"),
         dictgen::InsensitiveStr::Ascii("iliatrian"),
@@ -8762,12 +8762,12 @@ pub static WORD_UT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_US_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_US_CHILDREN),
+static WORD_US_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_US_CHILDREN),
     value: None,
 };
 
-static WORD_US_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_US_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_USA_NODE),
     None,
     Some(&WORD_USC_NODE),
@@ -8796,12 +8796,12 @@ static WORD_US_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_USU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USU_CHILDREN),
+static WORD_USU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USU_CHILDREN),
     value: None,
 };
 
-pub static WORD_USU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("age"),
@@ -8839,23 +8839,23 @@ pub static WORD_USU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_UST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UST_CHILDREN),
+static WORD_UST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UST_CHILDREN),
     value: None,
 };
 
-pub static WORD_UST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["using"]],
     range: 3..=3,
 };
 
-static WORD_USS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USS_CHILDREN),
+static WORD_USS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USS_CHILDREN),
     value: None,
 };
 
-pub static WORD_USS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("eful"),
@@ -8877,23 +8877,23 @@ pub static WORD_USS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_USR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USR_CHILDREN),
+static WORD_USR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USR_CHILDREN),
     value: None,
 };
 
-pub static WORD_USR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["sure"]],
     range: 1..=1,
 };
 
-static WORD_USP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USP_CHILDREN),
+static WORD_USP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USP_CHILDREN),
     value: None,
 };
 
-pub static WORD_USP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ported"),
         dictgen::InsensitiveStr::Ascii("tart"),
@@ -8903,12 +8903,12 @@ pub static WORD_USP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_USN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USN_CHILDREN),
+static WORD_USN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USN_CHILDREN),
     value: None,
 };
 
-pub static WORD_USN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("ig"),
@@ -8918,23 +8918,23 @@ pub static WORD_USN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_USL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USL_CHILDREN),
+static WORD_USL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USL_CHILDREN),
     value: None,
 };
 
-pub static WORD_USL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["useless"]],
     range: 3..=3,
 };
 
-static WORD_USI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USI_CHILDREN),
+static WORD_USI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USI_CHILDREN),
     value: None,
 };
 
-pub static WORD_USI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -8966,23 +8966,23 @@ pub static WORD_USI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_USF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USF_CHILDREN),
+static WORD_USF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USF_CHILDREN),
     value: None,
 };
 
-pub static WORD_USF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ul")],
     values: &[&["useful"]],
     range: 2..=2,
 };
 
-static WORD_USE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USE_CHILDREN),
+static WORD_USE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USE_CHILDREN),
     value: None,
 };
 
-pub static WORD_USE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("bility"),
@@ -9052,12 +9052,12 @@ pub static WORD_USE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_USC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USC_CHILDREN),
+static WORD_USC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USC_CHILDREN),
     value: None,
 };
 
-pub static WORD_USC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aled"),
         dictgen::InsensitiveStr::Ascii("cess"),
@@ -9066,12 +9066,12 @@ pub static WORD_USC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_USA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_USA_CHILDREN),
+static WORD_USA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_USA_CHILDREN),
     value: None,
 };
 
-pub static WORD_USA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_USA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -9081,12 +9081,12 @@ pub static WORD_USA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_UR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UR_CHILDREN),
+static WORD_UR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainum"),
         dictgen::InsensitiveStr::Ascii("anuim"),
@@ -9118,12 +9118,12 @@ pub static WORD_UR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_UQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UQ_CHILDREN),
+static WORD_UQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ests"),
@@ -9132,12 +9132,12 @@ pub static WORD_UQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_UP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UP_CHILDREN),
+static WORD_UP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UP_CHILDREN),
     value: None,
 };
 
-static WORD_UP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UPA_NODE),
     None,
     Some(&WORD_UPC_NODE),
@@ -9166,12 +9166,12 @@ static WORD_UP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPT_CHILDREN),
+static WORD_UPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adeable"),
         dictgen::InsensitiveStr::Ascii("date"),
@@ -9197,12 +9197,12 @@ pub static WORD_UPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPS_CHILDREN),
+static WORD_UPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ream"),
         dictgen::InsensitiveStr::Ascii("reamed"),
@@ -9280,12 +9280,12 @@ pub static WORD_UPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_UPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPR_CHILDREN),
+static WORD_UPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -9311,12 +9311,12 @@ pub static WORD_UPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_UPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPP_CHILDREN),
+static WORD_UPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ercas"),
         dictgen::InsensitiveStr::Ascii("ler"),
@@ -9350,12 +9350,12 @@ pub static WORD_UPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_UPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPL_CHILDREN),
+static WORD_UPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("adad"),
@@ -9423,34 +9423,34 @@ pub static WORD_UPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPI_CHILDREN),
+static WORD_UPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("on")],
     values: &[&["upon"]],
     range: 2..=2,
 };
 
-static WORD_UPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPH_CHILDREN),
+static WORD_UPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olstry")],
     values: &[&["upholstery"]],
     range: 6..=6,
 };
 
-static WORD_UPG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPG_CHILDREN),
+static WORD_UPG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -9524,12 +9524,12 @@ pub static WORD_UPG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_UPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPE_CHILDREN),
+static WORD_UPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rcase"),
@@ -9539,12 +9539,12 @@ pub static WORD_UPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_UPD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPD_CHILDREN),
+static WORD_UPD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -9598,23 +9598,23 @@ pub static WORD_UPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPC_CHILDREN),
+static WORD_UPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("omming")],
     values: &[&["upcoming"]],
     range: 6..=6,
 };
 
-static WORD_UPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UPA_CHILDREN),
+static WORD_UPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ck"),
         dictgen::InsensitiveStr::Ascii("date"),
@@ -9662,12 +9662,12 @@ pub static WORD_UPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UO_CHILDREN),
+static WORD_UO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("date"),
         dictgen::InsensitiveStr::Ascii("u"),
@@ -9676,12 +9676,12 @@ pub static WORD_UO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_UN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UN_CHILDREN),
+static WORD_UN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UN_CHILDREN),
     value: None,
 };
 
-static WORD_UN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNA_NODE),
     Some(&WORD_UNB_NODE),
     Some(&WORD_UNC_NODE),
@@ -9710,23 +9710,23 @@ static WORD_UN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNZ_NODE),
 ];
 
-static WORD_UNZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNZ_CHILDREN),
+static WORD_UNZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iped")],
     values: &[&["unzipped"]],
     range: 4..=4,
 };
 
-static WORD_UNX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNX_CHILDREN),
+static WORD_UNX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNX_CHILDREN),
     value: Some(&["unix"]),
 };
 
-pub static WORD_UNX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("epected"),
         dictgen::InsensitiveStr::Ascii("epectedly"),
@@ -9736,12 +9736,12 @@ pub static WORD_UNX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_UNW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNW_CHILDREN),
+static WORD_UNW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arrented"),
         dictgen::InsensitiveStr::Ascii("eildly"),
@@ -9773,12 +9773,12 @@ pub static WORD_UNW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_UNV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNV_CHILDREN),
+static WORD_UNV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailable"),
         dictgen::InsensitiveStr::Ascii("alid"),
@@ -9820,12 +9820,12 @@ pub static WORD_UNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_UNU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNU_CHILDREN),
+static WORD_UNU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blish"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -9861,12 +9861,12 @@ pub static WORD_UNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_UNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNT_CHILDREN),
+static WORD_UNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("argetted"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -9910,12 +9910,12 @@ pub static WORD_UNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_UNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNS_CHILDREN),
+static WORD_UNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNS_CHILDREN),
     value: None,
 };
 
-static WORD_UNS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNSA_NODE),
     None,
     Some(&WORD_UNSC_NODE),
@@ -9944,12 +9944,12 @@ static WORD_UNS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSY_CHILDREN),
+static WORD_UNSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chronise"),
         dictgen::InsensitiveStr::Ascii("chronised"),
@@ -9967,23 +9967,23 @@ pub static WORD_UNSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_UNSW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSW_CHILDREN),
+static WORD_UNSW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ithced")],
     values: &[&["unswitched"]],
     range: 6..=6,
 };
 
-static WORD_UNSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNSU_CHILDREN),
+static WORD_UNSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNSU_CHILDREN),
     value: None,
 };
 
-static WORD_UNSU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNSU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNSUA_NODE),
     Some(&WORD_UNSUB_NODE),
     Some(&WORD_UNSUC_NODE),
@@ -10012,12 +10012,12 @@ static WORD_UNSU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNSUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUS_CHILDREN),
+static WORD_UNSUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bcribe"),
         dictgen::InsensitiveStr::Ascii("bcribed"),
@@ -10039,12 +10039,12 @@ pub static WORD_UNSUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_UNSUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUR_CHILDREN),
+static WORD_UNSUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("prized"),
         dictgen::InsensitiveStr::Ascii("prizing"),
@@ -10054,12 +10054,12 @@ pub static WORD_UNSUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_UNSUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUP_CHILDREN),
+static WORD_UNSUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ortable"),
         dictgen::InsensitiveStr::Ascii("orted"),
@@ -10103,12 +10103,12 @@ pub static WORD_UNSUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNSUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUN_CHILDREN),
+static WORD_UNSUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("scribe"),
         dictgen::InsensitiveStr::Ascii("scribed"),
@@ -10117,45 +10117,45 @@ pub static WORD_UNSUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_UNSUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUF_CHILDREN),
+static WORD_UNSUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ficient")],
     values: &[&["insufficient"]],
     range: 7..=7,
 };
 
-static WORD_UNSUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUE_CHILDREN),
+static WORD_UNSUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["unused"]],
     range: 1..=1,
 };
 
-static WORD_UNSUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUD_CHILDREN),
+static WORD_UNSUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["unused", "unsuited"]],
     range: 2..=2,
 };
 
-static WORD_UNSUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUC_CHILDREN),
+static WORD_UNSUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccessful"),
         dictgen::InsensitiveStr::Ascii("ccessfully"),
@@ -10237,12 +10237,12 @@ pub static WORD_UNSUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_UNSUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUB_CHILDREN),
+static WORD_UNSUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cribe"),
         dictgen::InsensitiveStr::Ascii("scibe"),
@@ -10320,12 +10320,12 @@ pub static WORD_UNSUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_UNSUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSUA_CHILDREN),
+static WORD_UNSUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -10334,12 +10334,12 @@ pub static WORD_UNSUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_UNST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNST_CHILDREN),
+static WORD_UNST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNST_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abel"),
         dictgen::InsensitiveStr::Ascii("albe"),
@@ -10371,12 +10371,12 @@ pub static WORD_UNST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_UNSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSS_CHILDREN),
+static WORD_UNSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uccesful"),
         dictgen::InsensitiveStr::Ascii("upported"),
@@ -10385,12 +10385,12 @@ pub static WORD_UNSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=8,
 };
 
-static WORD_UNSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSP_CHILDREN),
+static WORD_UNSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecializated"),
         dictgen::InsensitiveStr::Ascii("ecificed"),
@@ -10482,12 +10482,12 @@ pub static WORD_UNSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=12,
 };
 
-static WORD_UNSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSO_CHILDREN),
+static WORD_UNSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clicited"),
         dictgen::InsensitiveStr::Ascii("licated"),
@@ -10511,23 +10511,23 @@ pub static WORD_UNSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSL_CHILDREN),
+static WORD_UNSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["unless", "useless"]],
     range: 3..=3,
 };
 
-static WORD_UNSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSI_CHILDREN),
+static WORD_UNSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bscribed"),
         dictgen::InsensitiveStr::Ascii("bstantiated"),
@@ -10555,12 +10555,12 @@ pub static WORD_UNSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_UNSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSH_CHILDREN),
+static WORD_UNSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arable"),
         dictgen::InsensitiveStr::Ascii("fit"),
@@ -10578,23 +10578,23 @@ pub static WORD_UNSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_UNSG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSG_CHILDREN),
+static WORD_UNSG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ined")],
     values: &[&["unsigned"]],
     range: 4..=4,
 };
 
-static WORD_UNSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSE_CHILDREN),
+static WORD_UNSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arcahble"),
         dictgen::InsensitiveStr::Ascii("ccessful"),
@@ -10648,12 +10648,12 @@ pub static WORD_UNSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_UNSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSC_CHILDREN),
+static WORD_UNSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessful"),
         dictgen::InsensitiveStr::Ascii("ubscribe"),
@@ -10663,12 +10663,12 @@ pub static WORD_UNSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_UNSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNSA_CHILDREN),
+static WORD_UNSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("nfe"),
@@ -10677,12 +10677,12 @@ pub static WORD_UNSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_UNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNR_CHILDREN),
+static WORD_UNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNR_CHILDREN),
     value: None,
 };
 
-static WORD_UNR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNRA_NODE),
     None,
     None,
@@ -10711,23 +10711,23 @@ static WORD_UNR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRW_CHILDREN),
+static WORD_UNRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itten")],
     values: &[&["unwritten"]],
     range: 5..=5,
 };
 
-static WORD_UNRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRP_CHILDREN),
+static WORD_UNRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oven"),
         dictgen::InsensitiveStr::Ascii("torect"),
@@ -10736,12 +10736,12 @@ pub static WORD_UNRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_UNRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRO_CHILDREN),
+static WORD_UNRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("ken"),
@@ -10751,45 +10751,45 @@ pub static WORD_UNRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_UNRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRN_CHILDREN),
+static WORD_UNRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aked")],
     values: &[&["unranked"]],
     range: 4..=4,
 };
 
-static WORD_UNRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRI_CHILDREN),
+static WORD_UNRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("stricted")],
     values: &[&["unrestricted"]],
     range: 8..=8,
 };
 
-static WORD_UNRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRG_CHILDREN),
+static WORD_UNRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("esiter")],
     values: &[&["unregister"]],
     range: 6..=6,
 };
 
-static WORD_UNRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNRE_CHILDREN),
+static WORD_UNRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNRE_CHILDREN),
     value: None,
 };
 
-static WORD_UNRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNREA_NODE),
     None,
     Some(&WORD_UNREC_NODE),
@@ -10818,12 +10818,12 @@ static WORD_UNRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRES_CHILDREN),
+static WORD_UNRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gister"),
         dictgen::InsensitiveStr::Ascii("gisterd"),
@@ -10873,12 +10873,12 @@ pub static WORD_UNRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_UNREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREP_CHILDREN),
+static WORD_UNREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entent"),
         dictgen::InsensitiveStr::Ascii("etant"),
@@ -10900,23 +10900,23 @@ pub static WORD_UNREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_UNREO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREO_CHILDREN),
+static WORD_UNREO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("verable")],
     values: &[&["unrecoverable"]],
     range: 7..=7,
 };
 
-static WORD_UNREL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREL_CHILDREN),
+static WORD_UNREL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aible"),
         dictgen::InsensitiveStr::Ascii("atd"),
@@ -10938,12 +10938,12 @@ pub static WORD_UNREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_UNREI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREI_CHILDREN),
+static WORD_UNREI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gister"),
         dictgen::InsensitiveStr::Ascii("gster"),
@@ -10961,12 +10961,12 @@ pub static WORD_UNREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_UNREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREG_CHILDREN),
+static WORD_UNREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ester"),
         dictgen::InsensitiveStr::Ascii("iste"),
@@ -11028,12 +11028,12 @@ pub static WORD_UNREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREC_CHILDREN),
+static WORD_UNREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gonized"),
         dictgen::InsensitiveStr::Ascii("hable"),
@@ -11065,12 +11065,12 @@ pub static WORD_UNREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_UNREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNREA_CHILDREN),
+static WORD_UNREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cahable"),
         dictgen::InsensitiveStr::Ascii("cahble"),
@@ -11122,12 +11122,12 @@ pub static WORD_UNREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNRA_CHILDREN),
+static WORD_UNRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kned"),
         dictgen::InsensitiveStr::Ascii("ndimized"),
@@ -11138,12 +11138,12 @@ pub static WORD_UNRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_UNQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNQ_CHILDREN),
+static WORD_UNQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arantined"),
         dictgen::InsensitiveStr::Ascii("aulified"),
@@ -11173,12 +11173,12 @@ pub static WORD_UNQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_UNP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNP_CHILDREN),
+static WORD_UNP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acke"),
         dictgen::InsensitiveStr::Ascii("acket"),
@@ -11292,12 +11292,12 @@ pub static WORD_UNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_UNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNO_CHILDREN),
+static WORD_UNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bstrusive"),
         dictgen::InsensitiveStr::Ascii("cde"),
@@ -11355,12 +11355,12 @@ pub static WORD_UNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_UNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNN_CHILDREN),
+static WORD_UNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acquired"),
         dictgen::InsensitiveStr::Ascii("cessarily"),
@@ -11484,12 +11484,12 @@ pub static WORD_UNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_UNM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNM_CHILDREN),
+static WORD_UNM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aanaged"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -11541,12 +11541,12 @@ pub static WORD_UNM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_UNL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNL_CHILDREN),
+static WORD_UNL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abled"),
         dictgen::InsensitiveStr::Ascii("ass"),
@@ -11592,12 +11592,12 @@ pub static WORD_UNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_UNK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNK_CHILDREN),
+static WORD_UNK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNK_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("known"),
         dictgen::InsensitiveStr::Ascii("mown"),
@@ -11661,12 +11661,12 @@ pub static WORD_UNK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_UNJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNJ_CHILDREN),
+static WORD_UNJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ustifed"),
         dictgen::InsensitiveStr::Ascii("ustifyed"),
@@ -11675,12 +11675,12 @@ pub static WORD_UNJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_UNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNI_CHILDREN),
+static WORD_UNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNI_CHILDREN),
     value: None,
 };
 
-static WORD_UNI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_UNIC_NODE),
@@ -11709,12 +11709,12 @@ static WORD_UNI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIV_CHILDREN),
+static WORD_UNIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eral"),
         dictgen::InsensitiveStr::Ascii("erally"),
@@ -11780,12 +11780,12 @@ pub static WORD_UNIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIT_CHILDREN),
+static WORD_UNIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("errupted"),
         dictgen::InsensitiveStr::Ascii("esstates"),
@@ -11829,12 +11829,12 @@ pub static WORD_UNIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_UNIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIS_CHILDREN),
+static WORD_UNIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gned"),
         dictgen::InsensitiveStr::Ascii("ntall"),
@@ -11856,12 +11856,12 @@ pub static WORD_UNIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIQ_CHILDREN),
+static WORD_UNIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ness"),
@@ -11887,12 +11887,12 @@ pub static WORD_UNIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_UNIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIO_CHILDREN),
+static WORD_UNIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIO_CHILDREN),
     value: Some(&["union"]),
 };
 
-pub static WORD_UNIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cde"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -11901,12 +11901,12 @@ pub static WORD_UNIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_UNIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNIN_CHILDREN),
+static WORD_UNIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNIN_CHILDREN),
     value: None,
 };
 
-static WORD_UNIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNINA_NODE),
     None,
     None,
@@ -11935,12 +11935,12 @@ static WORD_UNIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINT_CHILDREN),
+static WORD_UNINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ellegent"),
         dictgen::InsensitiveStr::Ascii("elligable"),
@@ -12016,12 +12016,12 @@ pub static WORD_UNINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_UNINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINS_CHILDREN),
+static WORD_UNINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipred"),
         dictgen::InsensitiveStr::Ascii("piried"),
@@ -12065,12 +12065,12 @@ pub static WORD_UNINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_UNINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINI_CHILDREN),
+static WORD_UNINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("shed"),
         dictgen::InsensitiveStr::Ascii("tailised"),
@@ -12120,12 +12120,12 @@ pub static WORD_UNINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNINF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINF_CHILDREN),
+static WORD_UNINF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rom"),
         dictgen::InsensitiveStr::Ascii("romed"),
@@ -12143,23 +12143,23 @@ pub static WORD_UNINF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_UNINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNINA_CHILDREN),
+static WORD_UNINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mous")],
     values: &[&["unanimous"]],
     range: 4..=4,
 };
 
-static WORD_UNIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIM_CHILDREN),
+static WORD_UNIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iplemented"),
         dictgen::InsensitiveStr::Ascii("pemented"),
@@ -12193,12 +12193,12 @@ pub static WORD_UNIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=10,
 };
 
-static WORD_UNIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIL_CHILDREN),
+static WORD_UNIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIL_CHILDREN),
     value: Some(&["until"]),
 };
 
-pub static WORD_UNIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aterallly"),
         dictgen::InsensitiveStr::Ascii("ateraly"),
@@ -12218,34 +12218,34 @@ pub static WORD_UNIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_UNIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIH_CHILDREN),
+static WORD_UNIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("abited")],
     values: &[&["uninhabited"]],
     range: 6..=6,
 };
 
-static WORD_UNIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIG_CHILDREN),
+static WORD_UNIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ned")],
     values: &[&["unsigned"]],
     range: 3..=3,
 };
 
-static WORD_UNIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIF_CHILDREN),
+static WORD_UNIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("form"),
@@ -12287,12 +12287,12 @@ pub static WORD_UNIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_UNID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNID_CHILDREN),
+static WORD_UNID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNID_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entifiedly"),
         dictgen::InsensitiveStr::Ascii("imensionnal"),
@@ -12302,12 +12302,12 @@ pub static WORD_UNID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=11,
 };
 
-static WORD_UNIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNIC_CHILDREN),
+static WORD_UNIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -12333,12 +12333,12 @@ pub static WORD_UNIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_UNH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNH_CHILDREN),
+static WORD_UNH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andeled"),
         dictgen::InsensitiveStr::Ascii("apppy"),
@@ -12368,12 +12368,12 @@ pub static WORD_UNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_UNG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNG_CHILDREN),
+static WORD_UNG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eneralizeable"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -12395,12 +12395,12 @@ pub static WORD_UNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_UNF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNF_CHILDREN),
+static WORD_UNF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailry"),
         dictgen::InsensitiveStr::Ascii("airy"),
@@ -12528,12 +12528,12 @@ pub static WORD_UNF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_UNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNE_CHILDREN),
+static WORD_UNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNE_CHILDREN),
     value: None,
 };
 
-static WORD_UNE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNEA_NODE),
     None,
     Some(&WORD_UNEC_NODE),
@@ -12562,12 +12562,12 @@ static WORD_UNE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNEX_CHILDREN),
+static WORD_UNEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNEX_CHILDREN),
     value: None,
 };
 
-static WORD_UNEX_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNEX_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_UNEXC_NODE),
@@ -12596,12 +12596,12 @@ static WORD_UNEX_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNEXS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEXS_CHILDREN),
+static WORD_UNEXS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEXS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEXS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEXS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pected"),
         dictgen::InsensitiveStr::Ascii("pectedly"),
@@ -12610,12 +12610,12 @@ pub static WORD_UNEXS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNEXP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEXP_CHILDREN),
+static WORD_UNEXP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEXP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEXP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEXP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acted"),
         dictgen::InsensitiveStr::Ascii("actedly"),
@@ -12725,12 +12725,12 @@ pub static WORD_UNEXP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_UNEXE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEXE_CHILDREN),
+static WORD_UNEXE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEXE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEXE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEXE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cpted"),
         dictgen::InsensitiveStr::Ascii("cptedly"),
@@ -12756,12 +12756,12 @@ pub static WORD_UNEXE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNEXC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEXC_CHILDREN),
+static WORD_UNEXC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEXC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEXC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEXC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("ectedly"),
@@ -12779,23 +12779,23 @@ pub static WORD_UNEXC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_UNEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEV_CHILDREN),
+static WORD_UNEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aluted")],
     values: &[&["unevaluated"]],
     range: 6..=6,
 };
 
-static WORD_UNES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNES_CHILDREN),
+static WORD_UNES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNES_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acpe"),
         dictgen::InsensitiveStr::Ascii("acped"),
@@ -12811,23 +12811,23 @@ pub static WORD_UNES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_UNER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNER_CHILDREN),
+static WORD_UNER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNER_CHILDREN),
     value: Some(&["under"]),
 };
 
-pub static WORD_UNER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lying")],
     values: &[&["underlying"]],
     range: 5..=5,
 };
 
-static WORD_UNEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEQ_CHILDREN),
+static WORD_UNEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ualities"),
         dictgen::InsensitiveStr::Ascii("uality"),
@@ -12836,12 +12836,12 @@ pub static WORD_UNEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEP_CHILDREN),
+static WORD_UNEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("ectedly"),
@@ -12850,12 +12850,12 @@ pub static WORD_UNEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_UNEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEN_CHILDREN),
+static WORD_UNEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crpt"),
         dictgen::InsensitiveStr::Ascii("crpted"),
@@ -12873,12 +12873,12 @@ pub static WORD_UNEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEM_CHILDREN),
+static WORD_UNEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ployeed"),
         dictgen::InsensitiveStr::Ascii("ployemnt"),
@@ -12900,12 +12900,12 @@ pub static WORD_UNEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEF_CHILDREN),
+static WORD_UNEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ficient"),
         dictgen::InsensitiveStr::Ascii("orceable"),
@@ -12915,23 +12915,23 @@ pub static WORD_UNEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_UNEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEE_CHILDREN),
+static WORD_UNEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ded")],
     values: &[&["unneeded", "unheeded", "needed"]],
     range: 3..=3,
 };
 
-static WORD_UNED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNED_CHILDREN),
+static WORD_UNED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNED_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cuated"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -12940,12 +12940,12 @@ pub static WORD_UNED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_UNEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEC_CHILDREN),
+static WORD_UNEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cesary"),
         dictgen::InsensitiveStr::Ascii("cessarily"),
@@ -12969,23 +12969,23 @@ pub static WORD_UNEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_UNEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNEA_CHILDREN),
+static WORD_UNEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lthy")],
     values: &[&["unhealthy"]],
     range: 4..=4,
 };
 
-static WORD_UND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UND_CHILDREN),
+static WORD_UND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UND_CHILDREN),
     value: None,
 };
 
-static WORD_UND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UND_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -13014,12 +13014,12 @@ static WORD_UND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDU_CHILDREN),
+static WORD_UNDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cumented"),
         dictgen::InsensitiveStr::Ascii("ee"),
@@ -13035,12 +13035,12 @@ pub static WORD_UNDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_UNDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDR_CHILDREN),
+static WORD_UNDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eground"),
         dictgen::InsensitiveStr::Ascii("estand"),
@@ -13050,12 +13050,12 @@ pub static WORD_UNDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_UNDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDO_CHILDREN),
+static WORD_UNDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("comented"),
         dictgen::InsensitiveStr::Ascii("ctrinated"),
@@ -13093,12 +13093,12 @@ pub static WORD_UNDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_UNDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDI_CHILDREN),
+static WORD_UNDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("covered"),
         dictgen::InsensitiveStr::Ascii("serable"),
@@ -13114,12 +13114,12 @@ pub static WORD_UNDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_UNDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDF_CHILDREN),
+static WORD_UNDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -13129,12 +13129,12 @@ pub static WORD_UNDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_UNDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNDE_CHILDREN),
+static WORD_UNDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNDE_CHILDREN),
     value: None,
 };
 
-static WORD_UNDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNDE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_UNDEB_NODE),
     Some(&WORD_UNDEC_NODE),
@@ -13163,12 +13163,12 @@ static WORD_UNDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNDET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDET_CHILDREN),
+static WORD_UNDET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDET_CHILDREN),
     value: Some(&["under"]),
 };
 
-pub static WORD_UNDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecable"),
         dictgen::InsensitiveStr::Ascii("erministic"),
@@ -13186,12 +13186,12 @@ pub static WORD_UNDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_UNDES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDES_CHILDREN),
+static WORD_UNDES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDES_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("core"),
         dictgen::InsensitiveStr::Ascii("cored"),
@@ -13223,12 +13223,12 @@ pub static WORD_UNDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_UNDER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNDER_CHILDREN),
+static WORD_UNDER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNDER_CHILDREN),
     value: None,
 };
 
-static WORD_UNDER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNDER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNDERA_NODE),
     Some(&WORD_UNDERB_NODE),
     Some(&WORD_UNDERC_NODE),
@@ -13257,12 +13257,12 @@ static WORD_UNDER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNDERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERY_CHILDREN),
+static WORD_UNDERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERY_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -13271,12 +13271,12 @@ pub static WORD_UNDERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_UNDERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERW_CHILDREN),
+static WORD_UNDERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("ager"),
@@ -13316,12 +13316,12 @@ pub static WORD_UNDERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_UNDERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERU_CHILDREN),
+static WORD_UNDERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ltilization"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -13331,12 +13331,12 @@ pub static WORD_UNDERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_UNDERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERT_CHILDREN),
+static WORD_UNDERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("acker"),
@@ -13380,12 +13380,12 @@ pub static WORD_UNDERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_UNDERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERS_CHILDREN),
+static WORD_UNDERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acn"),
         dictgen::InsensitiveStr::Ascii("and"),
@@ -13457,12 +13457,12 @@ pub static WORD_UNDERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_UNDERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERR_CHILDREN),
+static WORD_UNDERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aged"),
         dictgen::InsensitiveStr::Ascii("aker"),
@@ -13480,12 +13480,12 @@ pub static WORD_UNDERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_UNDERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERP_CHILDREN),
+static WORD_UNDERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ining"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -13503,23 +13503,23 @@ pub static WORD_UNDERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_UNDERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERO_CHILDREN),
+static WORD_UNDERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["undergo"]],
     range: 1..=1,
 };
 
-static WORD_UNDERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERN_CHILDREN),
+static WORD_UNDERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earth"),
         dictgen::InsensitiveStr::Ascii("eeth"),
@@ -13537,12 +13537,12 @@ pub static WORD_UNDERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_UNDERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERM_CHILDREN),
+static WORD_UNDERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imes"),
         dictgen::InsensitiveStr::Ascii("iming"),
@@ -13576,12 +13576,12 @@ pub static WORD_UNDERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_UNDERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERL_CHILDREN),
+static WORD_UNDERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayed"),
         dictgen::InsensitiveStr::Ascii("aying"),
@@ -13619,12 +13619,12 @@ pub static WORD_UNDERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_UNDERH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERH_CHILDREN),
+static WORD_UNDERH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eight"),
         dictgen::InsensitiveStr::Ascii("welming"),
@@ -13634,12 +13634,12 @@ pub static WORD_UNDERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=7,
 };
 
-static WORD_UNDERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERG_CHILDREN),
+static WORD_UNDERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -13669,12 +13669,12 @@ pub static WORD_UNDERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_UNDERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERF_CHILDREN),
+static WORD_UNDERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aker"),
         dictgen::InsensitiveStr::Ascii("iend"),
@@ -13696,12 +13696,12 @@ pub static WORD_UNDERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_UNDERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERE_CHILDREN),
+static WORD_UNDERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sitmate"),
         dictgen::InsensitiveStr::Ascii("stamate"),
@@ -13729,23 +13729,23 @@ pub static WORD_UNDERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=10,
 };
 
-static WORD_UNDERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERD_CHILDREN),
+static WORD_UNDERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ong")],
     values: &[&["underdog"]],
     range: 3..=3,
 };
 
-static WORD_UNDERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERC_CHILDREN),
+static WORD_UNDERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ling"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -13755,12 +13755,12 @@ pub static WORD_UNDERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_UNDERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERB_CHILDREN),
+static WORD_UNDERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aker"),
         dictgen::InsensitiveStr::Ascii("og"),
@@ -13769,12 +13769,12 @@ pub static WORD_UNDERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_UNDERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDERA_CHILDREN),
+static WORD_UNDERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stimate"),
         dictgen::InsensitiveStr::Ascii("stimated"),
@@ -13788,23 +13788,23 @@ pub static WORD_UNDERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=9,
 };
 
-static WORD_UNDEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEP_CHILDREN),
+static WORD_UNDEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("endend")],
     values: &[&["independent", "nondependent"]],
     range: 6..=6,
 };
 
-static WORD_UNDEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEN_CHILDREN),
+static WORD_UNDEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aible"),
         dictgen::InsensitiveStr::Ascii("aibly"),
@@ -13832,12 +13832,12 @@ pub static WORD_UNDEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_UNDEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEL_CHILDREN),
+static WORD_UNDEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ering"),
         dictgen::InsensitiveStr::Ascii("rying"),
@@ -13847,12 +13847,12 @@ pub static WORD_UNDEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_UNDEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEI_CHILDREN),
+static WORD_UNDEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nable"),
         dictgen::InsensitiveStr::Ascii("nably"),
@@ -13861,12 +13861,12 @@ pub static WORD_UNDEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_UNDEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEF_CHILDREN),
+static WORD_UNDEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ien"),
@@ -13896,45 +13896,45 @@ pub static WORD_UNDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_UNDED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDED_CHILDREN),
+static WORD_UNDED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDED_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ined")],
     values: &[&["undefined"]],
     range: 4..=4,
 };
 
-static WORD_UNDEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEC_CHILDREN),
+static WORD_UNDEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ideable")],
     values: &[&["undecidable"]],
     range: 7..=7,
 };
 
-static WORD_UNDEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNDEB_CHILDREN),
+static WORD_UNDEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNDEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNDEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNDEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iably")],
     values: &[&["undeniably"]],
     range: 5..=5,
 };
 
-static WORD_UNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNC_CHILDREN),
+static WORD_UNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNC_CHILDREN),
     value: None,
 };
 
-static WORD_UNC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_UNCA_NODE),
     None,
     None,
@@ -13963,23 +13963,23 @@ static WORD_UNC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCR_CHILDREN),
+static WORD_UNCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ypted")],
     values: &[&["unencrypted"]],
     range: 5..=5,
 };
 
-static WORD_UNCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNCO_CHILDREN),
+static WORD_UNCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNCO_CHILDREN),
     value: None,
 };
 
-static WORD_UNCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -14008,23 +14008,23 @@ static WORD_UNCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNCOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOV_CHILDREN),
+static WORD_UNCOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erted")],
     values: &[&["unconverted"]],
     range: 5..=5,
 };
 
-static WORD_UNCOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOU_CHILDREN),
+static WORD_UNCOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncious"),
         dictgen::InsensitiveStr::Ascii("nciously"),
@@ -14034,12 +14034,12 @@ pub static WORD_UNCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_UNCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOR_CHILDREN),
+static WORD_UNCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectly"),
         dictgen::InsensitiveStr::Ascii("elated"),
@@ -14057,12 +14057,12 @@ pub static WORD_UNCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_UNCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNCON_CHILDREN),
+static WORD_UNCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNCON_CHILDREN),
     value: None,
 };
 
-static WORD_UNCON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNCON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_UNCONC_NODE),
@@ -14091,12 +14091,12 @@ static WORD_UNCON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNCONV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONV_CHILDREN),
+static WORD_UNCONV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectional"),
         dictgen::InsensitiveStr::Ascii("encional"),
@@ -14120,12 +14120,12 @@ pub static WORD_UNCONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=9,
 };
 
-static WORD_UNCONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONT_CHILDREN),
+static WORD_UNCONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itutional"),
         dictgen::InsensitiveStr::Ascii("rained"),
@@ -14155,12 +14155,12 @@ pub static WORD_UNCONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=10,
 };
 
-static WORD_UNCONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONS_CHILDREN),
+static WORD_UNCONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciosly"),
         dictgen::InsensitiveStr::Ascii("cioulsy"),
@@ -14194,23 +14194,23 @@ pub static WORD_UNCONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_UNCONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONN_CHILDREN),
+static WORD_UNCONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ectes")],
     values: &[&["unconnected"]],
     range: 5..=5,
 };
 
-static WORD_UNCONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONF_CHILDREN),
+static WORD_UNCONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iged"),
         dictgen::InsensitiveStr::Ascii("ortability"),
@@ -14226,12 +14226,12 @@ pub static WORD_UNCONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=10,
 };
 
-static WORD_UNCOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOND_CHILDREN),
+static WORD_UNCOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isional"),
         dictgen::InsensitiveStr::Ascii("isionaly"),
@@ -14283,12 +14283,12 @@ pub static WORD_UNCOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=10,
 };
 
-static WORD_UNCONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCONC_CHILDREN),
+static WORD_UNCONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ious"),
         dictgen::InsensitiveStr::Ascii("iousness"),
@@ -14310,12 +14310,12 @@ pub static WORD_UNCONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=9,
 };
 
-static WORD_UNCOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOM_CHILDREN),
+static WORD_UNCOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ented"),
@@ -14421,23 +14421,23 @@ pub static WORD_UNCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_UNCOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOG_CHILDREN),
+static WORD_UNCOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nized")],
     values: &[&["unrecognized"]],
     range: 5..=5,
 };
 
-static WORD_UNCOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCOD_CHILDREN),
+static WORD_UNCOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("itionally"),
@@ -14446,34 +14446,34 @@ pub static WORD_UNCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_UNCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCL_CHILDREN),
+static WORD_UNCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["uncle", "unclear", "uncles"]],
     range: 2..=2,
 };
 
-static WORD_UNCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCK_CHILDREN),
+static WORD_UNCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nown")],
     values: &[&["unknown"]],
     range: 4..=4,
 };
 
-static WORD_UNCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCH_CHILDREN),
+static WORD_UNCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ache"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -14505,12 +14505,12 @@ pub static WORD_UNCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_UNCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCE_CHILDREN),
+static WORD_UNCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCE_CHILDREN),
     value: Some(&["once"]),
 };
 
-pub static WORD_UNCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hck"),
         dictgen::InsensitiveStr::Ascii("hcked"),
@@ -14572,12 +14572,12 @@ pub static WORD_UNCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_UNCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNCA_CHILDREN),
+static WORD_UNCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hnged"),
         dictgen::InsensitiveStr::Ascii("lcualted"),
@@ -14597,12 +14597,12 @@ pub static WORD_UNCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNB_CHILDREN),
+static WORD_UNB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alanaced"),
         dictgen::InsensitiveStr::Ascii("alenced"),
@@ -14720,12 +14720,12 @@ pub static WORD_UNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_UNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_UNA_CHILDREN),
+static WORD_UNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_UNA_CHILDREN),
     value: None,
 };
 
-static WORD_UNA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_UNA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_UNAB_NODE),
     Some(&WORD_UNAC_NODE),
@@ -14754,23 +14754,23 @@ static WORD_UNA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_UNAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAW_CHILDREN),
+static WORD_UNAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nsered")],
     values: &[&["unanswered"]],
     range: 6..=6,
 };
 
-static WORD_UNAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAV_CHILDREN),
+static WORD_UNAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aiable"),
         dictgen::InsensitiveStr::Ascii("aialable"),
@@ -14818,12 +14818,12 @@ pub static WORD_UNAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_UNAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAU_CHILDREN),
+static WORD_UNAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thenicated"),
         dictgen::InsensitiveStr::Ascii("thenticed"),
@@ -14841,12 +14841,12 @@ pub static WORD_UNAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=10,
 };
 
-static WORD_UNAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAT_CHILDREN),
+static WORD_UNAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("henticated"),
         dictgen::InsensitiveStr::Ascii("horised"),
@@ -14874,12 +14874,12 @@ pub static WORD_UNAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_UNAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAS_CHILDREN),
+static WORD_UNAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igned"),
         dictgen::InsensitiveStr::Ascii("nwered"),
@@ -14899,12 +14899,12 @@ pub static WORD_UNAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_UNAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAR_CHILDREN),
+static WORD_UNAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chvied"),
         dictgen::InsensitiveStr::Ascii("chving"),
@@ -14913,23 +14913,23 @@ pub static WORD_UNAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_UNAQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAQ_CHILDREN),
+static WORD_UNAQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uired")],
     values: &[&["unacquired"]],
     range: 5..=5,
 };
 
-static WORD_UNAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAP_CHILDREN),
+static WORD_UNAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pealling"),
         dictgen::InsensitiveStr::Ascii("peasing"),
@@ -14961,12 +14961,12 @@ pub static WORD_UNAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=11,
 };
 
-static WORD_UNAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAN_CHILDREN),
+static WORD_UNAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imoulsy"),
         dictgen::InsensitiveStr::Ascii("imuous"),
@@ -15010,12 +15010,12 @@ pub static WORD_UNAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_UNAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAM_CHILDREN),
+static WORD_UNAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bigious"),
         dictgen::InsensitiveStr::Ascii("bigous"),
@@ -15035,12 +15035,12 @@ pub static WORD_UNAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_UNAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAL_CHILDREN),
+static WORD_UNAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -15058,34 +15058,34 @@ pub static WORD_UNAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_UNAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAI_CHILDREN),
+static WORD_UNAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("valable")],
     values: &[&["unavailable"]],
     range: 7..=7,
 };
 
-static WORD_UNAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAH_CHILDREN),
+static WORD_UNAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ppy")],
     values: &[&["unhappy"]],
     range: 3..=3,
 };
 
-static WORD_UNAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAF_CHILDREN),
+static WORD_UNAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("fliated"),
@@ -15094,12 +15094,12 @@ pub static WORD_UNAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_UNAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAD_CHILDREN),
+static WORD_UNAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("vertantly"),
         dictgen::InsensitiveStr::Ascii("vertedly"),
@@ -15115,12 +15115,12 @@ pub static WORD_UNAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_UNAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAC_CHILDREN),
+static WORD_UNAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("captable"),
         dictgen::InsensitiveStr::Ascii("ceptible"),
@@ -15142,12 +15142,12 @@ pub static WORD_UNAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_UNAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UNAB_CHILDREN),
+static WORD_UNAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UNAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UNAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UNAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailable"),
         dictgen::InsensitiveStr::Ascii("ale"),
@@ -15165,12 +15165,12 @@ pub static WORD_UNAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_UM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UM_CHILDREN),
+static WORD_UM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UM_CHILDREN),
     value: None,
 };
 
-pub static WORD_UM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ambiguous"),
         dictgen::InsensitiveStr::Ascii("ark"),
@@ -15214,12 +15214,12 @@ pub static WORD_UM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_UL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UL_CHILDREN),
+static WORD_UL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UL_CHILDREN),
     value: None,
 };
 
-pub static WORD_UL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("imited"),
@@ -15281,12 +15281,12 @@ pub static WORD_UL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_UK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UK_CHILDREN),
+static WORD_UK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UK_CHILDREN),
     value: None,
 };
 
-pub static WORD_UK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arine"),
         dictgen::InsensitiveStr::Ascii("nown"),
@@ -15334,12 +15334,12 @@ pub static WORD_UK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_UI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UI_CHILDREN),
+static WORD_UI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UI_CHILDREN),
     value: None,
 };
 
-pub static WORD_UI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nque"),
         dictgen::InsensitiveStr::Ascii("que"),
@@ -15361,23 +15361,23 @@ pub static WORD_UI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_UH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UH_CHILDREN),
+static WORD_UH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UH_CHILDREN),
     value: None,
 };
 
-pub static WORD_UH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("andled")],
     values: &[&["unhandled"]],
     range: 6..=6,
 };
 
-static WORD_UG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UG_CHILDREN),
+static WORD_UG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UG_CHILDREN),
     value: None,
 };
 
-pub static WORD_UG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gly"),
         dictgen::InsensitiveStr::Ascii("glyness"),
@@ -15399,12 +15399,12 @@ pub static WORD_UG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_UF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UF_CHILDREN),
+static WORD_UF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UF_CHILDREN),
     value: None,
 };
 
-pub static WORD_UF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fer"),
         dictgen::InsensitiveStr::Ascii("fered"),
@@ -15415,12 +15415,12 @@ pub static WORD_UF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_UE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UE_CHILDREN),
+static WORD_UE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UE_CHILDREN),
     value: Some(&["use", "due"]),
 };
 
-pub static WORD_UE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ful"),
         dictgen::InsensitiveStr::Ascii("gister"),
@@ -15452,12 +15452,12 @@ pub static WORD_UE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_UD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UD_CHILDREN),
+static WORD_UD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UD_CHILDREN),
     value: None,
 };
 
-pub static WORD_UD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -15509,23 +15509,23 @@ pub static WORD_UD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_UC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UC_CHILDREN),
+static WORD_UC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UC_CHILDREN),
     value: None,
 };
 
-pub static WORD_UC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rrently")],
     values: &[&["currently"]],
     range: 7..=7,
 };
 
-static WORD_UB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_UB_CHILDREN),
+static WORD_UB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_UB_CHILDREN),
     value: None,
 };
 
-pub static WORD_UB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_UB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elieveble"),
         dictgen::InsensitiveStr::Ascii("elievebly"),
@@ -15571,12 +15571,12 @@ pub static WORD_UB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_T_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_T_CHILDREN),
+static WORD_T_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_T_CHILDREN),
     value: None,
 };
 
-static WORD_T_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_T_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TA_NODE),
     Some(&WORD_TB_NODE),
     Some(&WORD_TC_NODE),
@@ -15605,12 +15605,12 @@ static WORD_T_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TY_CHILDREN),
+static WORD_TY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("elnol"),
@@ -15726,12 +15726,12 @@ pub static WORD_TY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_TW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TW_CHILDREN),
+static WORD_TW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eek"),
         dictgen::InsensitiveStr::Ascii("eeked"),
@@ -15765,12 +15765,12 @@ pub static WORD_TW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_TU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TU_CHILDREN),
+static WORD_TU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TU_CHILDREN),
     value: None,
 };
 
-static WORD_TU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_TUC_NODE),
@@ -15799,12 +15799,12 @@ static WORD_TU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUT_CHILDREN),
+static WORD_TUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("oriales"),
@@ -15824,12 +15824,12 @@ pub static WORD_TUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_TUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUS_CHILDREN),
+static WORD_TUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("con"),
         dictgen::InsensitiveStr::Ascii("day"),
@@ -15849,12 +15849,12 @@ pub static WORD_TUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUR_CHILDREN),
+static WORD_TUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ains"),
@@ -15924,12 +15924,12 @@ pub static WORD_TUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_TUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUP_CHILDREN),
+static WORD_TUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -15951,12 +15951,12 @@ pub static WORD_TUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUO_CHILDREN),
+static WORD_TUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tiral"),
         dictgen::InsensitiveStr::Ascii("tirals"),
@@ -15965,12 +15965,12 @@ pub static WORD_TUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_TUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUN_CHILDREN),
+static WORD_TUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elled"),
         dictgen::InsensitiveStr::Ascii("elling"),
@@ -16004,34 +16004,34 @@ pub static WORD_TUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUH_CHILDREN),
+static WORD_TUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mbnail")],
     values: &[&["thumbnail"]],
     range: 6..=6,
 };
 
-static WORD_TUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUF_CHILDREN),
+static WORD_TUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ure")],
     values: &[&["future"]],
     range: 3..=3,
 };
 
-static WORD_TUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUE_CHILDREN),
+static WORD_TUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sdey"),
         dictgen::InsensitiveStr::Ascii("sdsay"),
@@ -16041,12 +16041,12 @@ pub static WORD_TUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_TUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TUC_CHILDREN),
+static WORD_TUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("ans"),
@@ -16055,12 +16055,12 @@ pub static WORD_TUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_TT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TT_CHILDREN),
+static WORD_TT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ached"),
         dictgen::InsensitiveStr::Ascii("ests"),
@@ -16082,12 +16082,12 @@ pub static WORD_TT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TS_CHILDREN),
+static WORD_TS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amina"),
         dictgen::InsensitiveStr::Ascii("nuami"),
@@ -16105,12 +16105,12 @@ pub static WORD_TS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_TR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TR_CHILDREN),
+static WORD_TR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TR_CHILDREN),
     value: None,
 };
 
-static WORD_TR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRA_NODE),
     None,
     Some(&WORD_TRC_NODE),
@@ -16139,12 +16139,12 @@ static WORD_TR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRY_CHILDREN),
+static WORD_TRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahrd"),
         dictgen::InsensitiveStr::Ascii("annical"),
@@ -16180,12 +16180,12 @@ pub static WORD_TRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRU_CHILDREN),
+static WORD_TRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRU_CHILDREN),
     value: None,
 };
 
-static WORD_TRU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRUA_NODE),
     Some(&WORD_TRUB_NODE),
     Some(&WORD_TRUC_NODE),
@@ -16214,23 +16214,23 @@ static WORD_TRU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRUW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUW_CHILDREN),
+static WORD_TRUW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUW_CHILDREN),
     value: Some(&["true"]),
 };
 
-pub static WORD_TRUW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_TRUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUT_CHILDREN),
+static WORD_TRUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hfullly"),
         dictgen::InsensitiveStr::Ascii("hfuly"),
@@ -16239,12 +16239,12 @@ pub static WORD_TRUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUS_CHILDREN),
+static WORD_TRUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hworthy"),
@@ -16274,23 +16274,23 @@ pub static WORD_TRUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_TRUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUR_CHILDREN),
+static WORD_TRUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ned")],
     values: &[&["turned"]],
     range: 3..=3,
 };
 
-static WORD_TRUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUN_CHILDREN),
+static WORD_TRUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUN_CHILDREN),
     value: Some(&["turn"]),
 };
 
-pub static WORD_TRUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acted"),
         dictgen::InsensitiveStr::Ascii("cat"),
@@ -16322,23 +16322,23 @@ pub static WORD_TRUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_TRUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUM_CHILDREN),
+static WORD_TRUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("endously")],
     values: &[&["tremendously"]],
     range: 8..=8,
 };
 
-static WORD_TRUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUL_CHILDREN),
+static WORD_TRUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ey"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -16347,23 +16347,23 @@ pub static WORD_TRUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=2,
 };
 
-static WORD_TRUK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUK_CHILDREN),
+static WORD_TRUK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ish")],
     values: &[&["turkish"]],
     range: 3..=3,
 };
 
-static WORD_TRUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUI_CHILDREN),
+static WORD_TRUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("mph"),
@@ -16372,12 +16372,12 @@ pub static WORD_TRUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TRUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUG_CHILDREN),
+static WORD_TRUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -16387,12 +16387,12 @@ pub static WORD_TRUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TRUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUE_CHILDREN),
+static WORD_TRUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lly"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -16401,23 +16401,23 @@ pub static WORD_TRUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TRUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUD_CHILDREN),
+static WORD_TRUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nle")],
     values: &[&["trundle"]],
     range: 3..=3,
 };
 
-static WORD_TRUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUC_CHILDREN),
+static WORD_TRUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -16445,12 +16445,12 @@ pub static WORD_TRUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_TRUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUB_CHILDREN),
+static WORD_TRUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ador"),
         dictgen::InsensitiveStr::Ascii("adors"),
@@ -16484,12 +16484,12 @@ pub static WORD_TRUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TRUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRUA_CHILDREN),
+static WORD_TRUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matic"),
         dictgen::InsensitiveStr::Ascii("matized"),
@@ -16498,12 +16498,12 @@ pub static WORD_TRUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRR_CHILDREN),
+static WORD_TRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iger"),
         dictgen::InsensitiveStr::Ascii("igered"),
@@ -16527,23 +16527,23 @@ pub static WORD_TRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_TRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRP_CHILDREN),
+static WORD_TRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oical")],
     values: &[&["tropical"]],
     range: 5..=5,
 };
 
-static WORD_TRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRO_CHILDREN),
+static WORD_TRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRO_CHILDREN),
     value: Some(&["to"]),
 };
 
-static WORD_TRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_TROB_NODE),
     Some(&WORD_TROC_NODE),
@@ -16572,23 +16572,23 @@ static WORD_TRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TROW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROW_CHILDREN),
+static WORD_TROW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("n")],
     values: &[&["thrown"]],
     range: 1..=1,
 };
 
-static WORD_TROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROU_CHILDREN),
+static WORD_TROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bador"),
         dictgen::InsensitiveStr::Ascii("badors"),
@@ -16646,12 +16646,12 @@ pub static WORD_TROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_TROT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROT_CHILDREN),
+static WORD_TROT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("illa"),
         dictgen::InsensitiveStr::Ascii("ski"),
@@ -16699,12 +16699,12 @@ pub static WORD_TROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TROP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROP_CHILDREN),
+static WORD_TROP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cial"),
         dictgen::InsensitiveStr::Ascii("edo"),
@@ -16713,12 +16713,12 @@ pub static WORD_TROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_TROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROO_CHILDREN),
+static WORD_TROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("so"),
         dictgen::InsensitiveStr::Ascii("sos"),
@@ -16734,23 +16734,23 @@ pub static WORD_TROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_TRON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRON_CHILDREN),
+static WORD_TRON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRON_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ado")],
     values: &[&["tornado"]],
     range: 3..=3,
 };
 
-static WORD_TROL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROL_CHILDREN),
+static WORD_TROL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eld"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -16761,23 +16761,23 @@ pub static WORD_TROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_TROH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROH_CHILDREN),
+static WORD_TROH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pies")],
     values: &[&["trophies"]],
     range: 4..=4,
 };
 
-static WORD_TROG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROG_CHILDREN),
+static WORD_TROG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ladite"),
         dictgen::InsensitiveStr::Ascii("ladites"),
@@ -16815,34 +16815,34 @@ pub static WORD_TROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_TROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROC_CHILDREN),
+static WORD_TROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hlight")],
     values: &[&["torchlight"]],
     range: 6..=6,
 };
 
-static WORD_TROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TROB_CHILDREN),
+static WORD_TROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TROB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TROB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["trouble"]],
     range: 2..=2,
 };
 
-static WORD_TRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRN_CHILDREN),
+static WORD_TRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asfers"),
         dictgen::InsensitiveStr::Ascii("asmit"),
@@ -16866,12 +16866,12 @@ pub static WORD_TRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_TRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRI_CHILDREN),
+static WORD_TRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRI_CHILDREN),
     value: None,
 };
 
-static WORD_TRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRIA_NODE),
     Some(&WORD_TRIB_NODE),
     Some(&WORD_TRIC_NODE),
@@ -16900,23 +16900,23 @@ static WORD_TRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIY_CHILDREN),
+static WORD_TRIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["trying"]],
     range: 3..=3,
 };
 
-static WORD_TRIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIV_CHILDREN),
+static WORD_TRIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -16927,12 +16927,12 @@ pub static WORD_TRIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_TRIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIU_CHILDREN),
+static WORD_TRIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angulate"),
         dictgen::InsensitiveStr::Ascii("mpth"),
@@ -16941,12 +16941,12 @@ pub static WORD_TRIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_TRIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIS_CHILDREN),
+static WORD_TRIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cadecafobia"),
         dictgen::InsensitiveStr::Ascii("cadecaphobia"),
@@ -16974,12 +16974,12 @@ pub static WORD_TRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 11..=13,
 };
 
-static WORD_TRIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIP_CHILDREN),
+static WORD_TRIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("eld"),
@@ -17009,12 +17009,12 @@ pub static WORD_TRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TRIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIO_CHILDREN),
+static WORD_TRIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lgy"),
         dictgen::InsensitiveStr::Ascii("logy"),
@@ -17023,12 +17023,12 @@ pub static WORD_TRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_TRIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIN_CHILDREN),
+static WORD_TRIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agle"),
         dictgen::InsensitiveStr::Ascii("agles"),
@@ -17062,12 +17062,12 @@ pub static WORD_TRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_TRIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIM_CHILDREN),
+static WORD_TRIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -17083,12 +17083,12 @@ pub static WORD_TRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TRIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIL_CHILDREN),
+static WORD_TRIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inar"),
         dictgen::InsensitiveStr::Ascii("ineal"),
@@ -17098,12 +17098,12 @@ pub static WORD_TRIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_TRIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIK_CHILDREN),
+static WORD_TRIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIK_CHILDREN),
     value: Some(&["trick", "trike"]),
 };
 
-pub static WORD_TRIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ery"),
@@ -17119,12 +17119,12 @@ pub static WORD_TRIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_TRIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIG_CHILDREN),
+static WORD_TRIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -17172,12 +17172,12 @@ pub static WORD_TRIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_TRID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRID_CHILDREN),
+static WORD_TRID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRID_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itional"),
         dictgen::InsensitiveStr::Ascii("net"),
@@ -17186,12 +17186,12 @@ pub static WORD_TRID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIC_CHILDREN),
+static WORD_TRIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("key"),
         dictgen::InsensitiveStr::Ascii("kyer"),
@@ -17201,12 +17201,12 @@ pub static WORD_TRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_TRIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIB_CHILDREN),
+static WORD_TRIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uanl"),
         dictgen::InsensitiveStr::Ascii("unaal"),
@@ -17215,12 +17215,12 @@ pub static WORD_TRIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_TRIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRIA_CHILDREN),
+static WORD_TRIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ler"),
         dictgen::InsensitiveStr::Ascii("lers"),
@@ -17278,12 +17278,12 @@ pub static WORD_TRIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_TRH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRH_CHILDREN),
+static WORD_TRH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("illing"),
@@ -17294,12 +17294,12 @@ pub static WORD_TRH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_TRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRG_CHILDREN),
+static WORD_TRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gers"),
         dictgen::InsensitiveStr::Ascii("istration"),
@@ -17308,12 +17308,12 @@ pub static WORD_TRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_TRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRE_CHILDREN),
+static WORD_TRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRE_CHILDREN),
     value: Some(&["tree"]),
 };
 
-pub static WORD_TRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adet"),
         dictgen::InsensitiveStr::Ascii("aeted"),
@@ -17429,23 +17429,23 @@ pub static WORD_TRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRC_CHILDREN),
+static WORD_TRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["tracer"]],
     range: 2..=2,
 };
 
-static WORD_TRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRA_CHILDREN),
+static WORD_TRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRA_CHILDREN),
     value: None,
 };
 
-static WORD_TRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_TRAB_NODE),
     Some(&WORD_TRAC_NODE),
@@ -17474,12 +17474,12 @@ static WORD_TRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAV_CHILDREN),
+static WORD_TRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eersal"),
@@ -17575,12 +17575,12 @@ pub static WORD_TRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TRAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAU_CHILDREN),
+static WORD_TRAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matisch"),
         dictgen::InsensitiveStr::Ascii("metized"),
@@ -17590,12 +17590,12 @@ pub static WORD_TRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_TRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAT_CHILDREN),
+static WORD_TRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ior"),
         dictgen::InsensitiveStr::Ascii("iors"),
@@ -17604,12 +17604,12 @@ pub static WORD_TRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_TRAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRAS_CHILDREN),
+static WORD_TRAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRAS_CHILDREN),
     value: None,
 };
 
-static WORD_TRAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRAS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRASA_NODE),
     None,
     Some(&WORD_TRASC_NODE),
@@ -17638,23 +17638,23 @@ static WORD_TRAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRASV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASV_CHILDREN),
+static WORD_TRASV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ersing")],
     values: &[&["traversing"]],
     range: 6..=6,
 };
 
-static WORD_TRASP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASP_CHILDREN),
+static WORD_TRASP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arency"),
         dictgen::InsensitiveStr::Ascii("arent"),
@@ -17688,12 +17688,12 @@ pub static WORD_TRASP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_TRASN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASN_CHILDREN),
+static WORD_TRASN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("action"),
         dictgen::InsensitiveStr::Ascii("actions"),
@@ -17781,12 +17781,12 @@ pub static WORD_TRASN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_TRASM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASM_CHILDREN),
+static WORD_TRASM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ission"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -17795,12 +17795,12 @@ pub static WORD_TRASM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TRASL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASL_CHILDREN),
+static WORD_TRASL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("alated"),
@@ -17832,12 +17832,12 @@ pub static WORD_TRASL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_TRASI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASI_CHILDREN),
+static WORD_TRASI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tive"),
@@ -17846,12 +17846,12 @@ pub static WORD_TRASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_TRASF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASF_CHILDREN),
+static WORD_TRASF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erred"),
@@ -17885,12 +17885,12 @@ pub static WORD_TRASF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_TRASC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASC_CHILDREN),
+static WORD_TRASC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ription"),
@@ -17899,34 +17899,34 @@ pub static WORD_TRASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRASA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRASA_CHILDREN),
+static WORD_TRASA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRASA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRASA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ction")],
     values: &[&["transaction"]],
     range: 5..=5,
 };
 
-static WORD_TRAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAR_CHILDREN),
+static WORD_TRAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("get")],
     values: &[&["target"]],
     range: 3..=3,
 };
 
-static WORD_TRAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAP_CHILDREN),
+static WORD_TRAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eziod"),
         dictgen::InsensitiveStr::Ascii("eziodal"),
@@ -17935,12 +17935,12 @@ pub static WORD_TRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRAN_CHILDREN),
+static WORD_TRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRAN_CHILDREN),
     value: None,
 };
 
-static WORD_TRAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRANA_NODE),
     None,
     Some(&WORD_TRANC_NODE),
@@ -17969,12 +17969,12 @@ static WORD_TRAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRANZ_NODE),
 ];
 
-static WORD_TRANZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANZ_CHILDREN),
+static WORD_TRANZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("former"),
         dictgen::InsensitiveStr::Ascii("istor"),
@@ -17990,12 +17990,12 @@ pub static WORD_TRANZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TRANV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANV_CHILDREN),
+static WORD_TRANV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ersal"),
         dictgen::InsensitiveStr::Ascii("erse"),
@@ -18011,12 +18011,12 @@ pub static WORD_TRANV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_TRANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRANS_CHILDREN),
+static WORD_TRANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRANS_CHILDREN),
     value: None,
 };
 
-static WORD_TRANS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRANS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRANSA_NODE),
     None,
     Some(&WORD_TRANSC_NODE),
@@ -18045,12 +18045,12 @@ static WORD_TRANS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRANSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSY_CHILDREN),
+static WORD_TRANSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lmania"),
         dictgen::InsensitiveStr::Ascii("lvanai"),
@@ -18066,12 +18066,12 @@ pub static WORD_TRANSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=7,
 };
 
-static WORD_TRANSV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSV_CHILDREN),
+static WORD_TRANSV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orm"),
         dictgen::InsensitiveStr::Ascii("ormation"),
@@ -18089,23 +18089,23 @@ pub static WORD_TRANSV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_TRANSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSU_CHILDREN),
+static WORD_TRANSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lcent")],
     values: &[&["translucent"]],
     range: 5..=5,
 };
 
-static WORD_TRANST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANST_CHILDREN),
+static WORD_TRANST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANST_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ator"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -18137,12 +18137,12 @@ pub static WORD_TRANST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_TRANSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSS_CHILDREN),
+static WORD_TRANSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cript"),
         dictgen::InsensitiveStr::Ascii("cription"),
@@ -18168,12 +18168,12 @@ pub static WORD_TRANSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_TRANSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TRANSP_CHILDREN),
+static WORD_TRANSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TRANSP_CHILDREN),
     value: None,
 };
 
-static WORD_TRANSP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TRANSP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TRANSPA_NODE),
     None,
     None,
@@ -18202,23 +18202,23 @@ static WORD_TRANSP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TRANSPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPS_CHILDREN),
+static WORD_TRANSPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ition")],
     values: &[&["transposition"]],
     range: 5..=5,
 };
 
-static WORD_TRANSPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPR_CHILDREN),
+static WORD_TRANSPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encies"),
         dictgen::InsensitiveStr::Ascii("ency"),
@@ -18250,12 +18250,12 @@ pub static WORD_TRANSPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_TRANSPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPO_CHILDREN),
+static WORD_TRANSPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -18299,12 +18299,12 @@ pub static WORD_TRANSPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_TRANSPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPL_CHILDREN),
+static WORD_TRANSPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("anet"),
@@ -18326,12 +18326,12 @@ pub static WORD_TRANSPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_TRANSPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPH_CHILDREN),
+static WORD_TRANSPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oic"),
         dictgen::InsensitiveStr::Ascii("onic"),
@@ -18341,12 +18341,12 @@ pub static WORD_TRANSPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_TRANSPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPE_CHILDREN),
+static WORD_TRANSPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncies"),
         dictgen::InsensitiveStr::Ascii("ncy"),
@@ -18376,12 +18376,12 @@ pub static WORD_TRANSPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=7,
 };
 
-static WORD_TRANSPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPA_CHILDREN),
+static WORD_TRANSPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("cencies"),
@@ -18481,12 +18481,12 @@ pub static WORD_TRANSPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_TRANSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSO_CHILDREN),
+static WORD_TRANSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cde"),
         dictgen::InsensitiveStr::Ascii("cded"),
@@ -18548,12 +18548,12 @@ pub static WORD_TRANSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_TRANSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSM_CHILDREN),
+static WORD_TRANSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atter"),
         dictgen::InsensitiveStr::Ascii("ision"),
@@ -18623,12 +18623,12 @@ pub static WORD_TRANSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_TRANSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSL_CHILDREN),
+static WORD_TRANSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("astion"),
         dictgen::InsensitiveStr::Ascii("atation"),
@@ -18678,12 +18678,12 @@ pub static WORD_TRANSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_TRANSK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSK_CHILDREN),
+static WORD_TRANSK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ript"),
         dictgen::InsensitiveStr::Ascii("ription"),
@@ -18692,12 +18692,12 @@ pub static WORD_TRANSK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_TRANSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSI_CHILDREN),
+static WORD_TRANSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cion"),
         dictgen::InsensitiveStr::Ascii("cional"),
@@ -18785,23 +18785,23 @@ pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_TRANSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSH_CHILDREN),
+static WORD_TRANSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pobic")],
     values: &[&["transphobic"]],
     range: 5..=5,
 };
 
-static WORD_TRANSG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSG_CHILDREN),
+static WORD_TRANSG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eder"),
         dictgen::InsensitiveStr::Ascii("emder"),
@@ -18831,12 +18831,12 @@ pub static WORD_TRANSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_TRANSF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSF_CHILDREN),
+static WORD_TRANSF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("armers"),
         dictgen::InsensitiveStr::Ascii("arring"),
@@ -18968,12 +18968,12 @@ pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_TRANSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSE_CHILDREN),
+static WORD_TRANSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("int"),
@@ -18991,12 +18991,12 @@ pub static WORD_TRANSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_TRANSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSC_CHILDREN),
+static WORD_TRANSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -19108,12 +19108,12 @@ pub static WORD_TRANSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=13,
 };
 
-static WORD_TRANSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANSA_CHILDREN),
+static WORD_TRANSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -19179,12 +19179,12 @@ pub static WORD_TRANSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_TRANP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANP_CHILDREN),
+static WORD_TRANP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arency"),
         dictgen::InsensitiveStr::Ascii("arent"),
@@ -19216,23 +19216,23 @@ pub static WORD_TRANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANN_CHILDREN),
+static WORD_TRANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sexual")],
     values: &[&["transsexual"]],
     range: 6..=6,
 };
 
-static WORD_TRANM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANM_CHILDREN),
+static WORD_TRANM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ission"),
         dictgen::InsensitiveStr::Ascii("ist"),
@@ -19250,12 +19250,12 @@ pub static WORD_TRANM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRANL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANL_CHILDREN),
+static WORD_TRANL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("astion"),
         dictgen::InsensitiveStr::Ascii("atable"),
@@ -19293,12 +19293,12 @@ pub static WORD_TRANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANI_CHILDREN),
+static WORD_TRANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -19330,23 +19330,23 @@ pub static WORD_TRANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_TRANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANG_CHILDREN),
+static WORD_TRANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("les")],
     values: &[&["triangles"]],
     range: 3..=3,
 };
 
-static WORD_TRANF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANF_CHILDREN),
+static WORD_TRANF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -19382,12 +19382,12 @@ pub static WORD_TRANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_TRAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAND_CHILDREN),
+static WORD_TRAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gender"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -19403,12 +19403,12 @@ pub static WORD_TRAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRANC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANC_CHILDREN),
+static WORD_TRANC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -19436,12 +19436,12 @@ pub static WORD_TRANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_TRANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRANA_CHILDREN),
+static WORD_TRANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -19465,12 +19465,12 @@ pub static WORD_TRANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAM_CHILDREN),
+static WORD_TRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("as"),
@@ -19510,12 +19510,12 @@ pub static WORD_TRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_TRAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAL_CHILDREN),
+static WORD_TRAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAL_CHILDREN),
     value: Some(&["trail", "trial"]),
 };
 
-pub static WORD_TRAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ier"),
@@ -19560,12 +19560,12 @@ pub static WORD_TRAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_TRAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAK_CHILDREN),
+static WORD_TRAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAK_CHILDREN),
     value: Some(&["track"]),
 };
 
-pub static WORD_TRAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cers"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -19583,12 +19583,12 @@ pub static WORD_TRAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_TRAJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAJ_CHILDREN),
+static WORD_TRAJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actory"),
         dictgen::InsensitiveStr::Ascii("ecotry"),
@@ -19597,12 +19597,12 @@ pub static WORD_TRAJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_TRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAI_CHILDREN),
+static WORD_TRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ds"),
         dictgen::InsensitiveStr::Ascii("ge"),
@@ -19686,12 +19686,12 @@ pub static WORD_TRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_TRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAG_CHILDREN),
+static WORD_TRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectory"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -19713,12 +19713,12 @@ pub static WORD_TRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TRAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAF_CHILDREN),
+static WORD_TRAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fice"),
         dictgen::InsensitiveStr::Ascii("ficed"),
@@ -19734,12 +19734,12 @@ pub static WORD_TRAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAD_CHILDREN),
+static WORD_TRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dition"),
         dictgen::InsensitiveStr::Ascii("ditional"),
@@ -19783,12 +19783,12 @@ pub static WORD_TRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_TRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAC_CHILDREN),
+static WORD_TRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eablity"),
         dictgen::InsensitiveStr::Ascii("eer"),
@@ -19822,12 +19822,12 @@ pub static WORD_TRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_TRAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TRAB_CHILDREN),
+static WORD_TRAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TRAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TRAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ajao"),
         dictgen::InsensitiveStr::Ascii("ajdo"),
@@ -19837,23 +19837,23 @@ pub static WORD_TRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_TQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TQ_CHILDREN),
+static WORD_TQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rget")],
     values: &[&["target"]],
     range: 4..=4,
 };
 
-static WORD_TP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TP_CHILDREN),
+static WORD_TP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("os"),
@@ -19875,12 +19875,12 @@ pub static WORD_TP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_TO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TO_CHILDREN),
+static WORD_TO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TO_CHILDREN),
     value: None,
 };
 
-static WORD_TO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TOA_NODE),
     Some(&WORD_TOB_NODE),
     Some(&WORD_TOC_NODE),
@@ -19909,12 +19909,12 @@ static WORD_TO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOX_CHILDREN),
+static WORD_TOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("icitity"),
@@ -19925,12 +19925,12 @@ pub static WORD_TOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_TOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOW_CHILDREN),
+static WORD_TOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ords"),
         dictgen::InsensitiveStr::Ascii("rad"),
@@ -19940,12 +19940,12 @@ pub static WORD_TOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_TOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOU_CHILDREN),
+static WORD_TOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOU_CHILDREN),
     value: Some(&["you"]),
 };
 
-pub static WORD_TOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bles"),
@@ -20045,12 +20045,12 @@ pub static WORD_TOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOT_CHILDREN),
+static WORD_TOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alitara"),
         dictgen::InsensitiveStr::Ascii("alitaran"),
@@ -20098,12 +20098,12 @@ pub static WORD_TOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_TOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOS_CHILDREN),
+static WORD_TOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biba"),
         dictgen::InsensitiveStr::Ascii("day"),
@@ -20112,12 +20112,12 @@ pub static WORD_TOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_TOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOR_CHILDREN),
+static WORD_TOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ando"),
         dictgen::InsensitiveStr::Ascii("andoes"),
@@ -20227,12 +20227,12 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOP_CHILDREN),
+static WORD_TOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icaizer"),
         dictgen::InsensitiveStr::Ascii("logical"),
@@ -20262,12 +20262,12 @@ pub static WORD_TOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_TOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOO_CHILDREN),
+static WORD_TOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("gle"),
@@ -20313,12 +20313,12 @@ pub static WORD_TOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TON_CHILDREN),
+static WORD_TON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TON_CHILDREN),
     value: None,
 };
 
-pub static WORD_TON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("giht"),
@@ -20338,12 +20338,12 @@ pub static WORD_TON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_TOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOM_CHILDREN),
+static WORD_TOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arow"),
         dictgen::InsensitiveStr::Ascii("arrow"),
@@ -20397,12 +20397,12 @@ pub static WORD_TOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_TOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOL_CHILDREN),
+static WORD_TOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arable"),
         dictgen::InsensitiveStr::Ascii("earnce"),
@@ -20454,12 +20454,12 @@ pub static WORD_TOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOK_CHILDREN),
+static WORD_TOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enizaing"),
         dictgen::InsensitiveStr::Ascii("enizaiton"),
@@ -20469,23 +20469,23 @@ pub static WORD_TOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_TOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOI_CHILDREN),
+static WORD_TOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOI_CHILDREN),
     value: Some(&["to", "toy"]),
 };
 
-pub static WORD_TOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("letts")],
     values: &[&["toilets"]],
     range: 5..=5,
 };
 
-static WORD_TOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOG_CHILDREN),
+static WORD_TOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ater"),
         dictgen::InsensitiveStr::Ascii("ather"),
@@ -20543,12 +20543,12 @@ pub static WORD_TOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOE_CHILDREN),
+static WORD_TOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kn"),
         dictgen::InsensitiveStr::Ascii("ther"),
@@ -20557,12 +20557,12 @@ pub static WORD_TOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_TOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOD_CHILDREN),
+static WORD_TOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ya"),
@@ -20571,12 +20571,12 @@ pub static WORD_TOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_TOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOC_CHILDREN),
+static WORD_TOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hes"),
         dictgen::InsensitiveStr::Ascii("ksen"),
@@ -20594,12 +20594,12 @@ pub static WORD_TOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_TOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOB_CHILDREN),
+static WORD_TOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baco"),
         dictgen::InsensitiveStr::Ascii("ot"),
@@ -20608,12 +20608,12 @@ pub static WORD_TOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_TOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TOA_CHILDREN),
+static WORD_TOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hiba"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -20622,12 +20622,12 @@ pub static WORD_TOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_TN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TN_CHILDREN),
+static WORD_TN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -20636,12 +20636,12 @@ pub static WORD_TN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_TM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TM_CHILDREN),
+static WORD_TM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("is"),
@@ -20651,12 +20651,12 @@ pub static WORD_TM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TL_CHILDREN),
+static WORD_TL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("aking"),
@@ -20665,12 +20665,12 @@ pub static WORD_TL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_TK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TK_CHILDREN),
+static WORD_TK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -20681,12 +20681,12 @@ pub static WORD_TK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_TJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TJ_CHILDREN),
+static WORD_TJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("he"),
@@ -20696,12 +20696,12 @@ pub static WORD_TJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_TI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TI_CHILDREN),
+static WORD_TI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TI_CHILDREN),
     value: None,
 };
 
-static WORD_TI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TIA_NODE),
     Some(&WORD_TIB_NODE),
     Some(&WORD_TIC_NODE),
@@ -20730,23 +20730,23 @@ static WORD_TI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TIW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIW_CHILDREN),
+static WORD_TIW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ards")],
     values: &[&["towards"]],
     range: 4..=4,
 };
 
-static WORD_TIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIT_CHILDREN),
+static WORD_TIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainum"),
         dictgen::InsensitiveStr::Ascii("anim"),
@@ -20770,12 +20770,12 @@ pub static WORD_TIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_TIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIR_CHILDREN),
+static WORD_TIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angle"),
         dictgen::InsensitiveStr::Ascii("angles"),
@@ -20795,12 +20795,12 @@ pub static WORD_TIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_TIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIP_CHILDREN),
+static WORD_TIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -20809,12 +20809,12 @@ pub static WORD_TIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_TIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIO_CHILDREN),
+static WORD_TIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIO_CHILDREN),
     value: Some(&["to"]),
 };
 
-pub static WORD_TIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lets"),
         dictgen::InsensitiveStr::Ascii("me"),
@@ -20823,12 +20823,12 @@ pub static WORD_TIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_TIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIN_CHILDREN),
+static WORD_TIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dergarten"),
         dictgen::InsensitiveStr::Ascii("gs"),
@@ -20838,12 +20838,12 @@ pub static WORD_TIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_TIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIM_CHILDREN),
+static WORD_TIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("delta"),
         dictgen::InsensitiveStr::Ascii("edlta"),
@@ -20943,12 +20943,12 @@ pub static WORD_TIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIL_CHILDREN),
+static WORD_TIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("da"),
         dictgen::InsensitiveStr::Ascii("lt"),
@@ -20959,23 +20959,23 @@ pub static WORD_TIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_TII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TII_CHILDREN),
+static WORD_TII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TII_CHILDREN),
     value: None,
 };
 
-pub static WORD_TII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tle")],
     values: &[&["title"]],
     range: 3..=3,
 };
 
-static WORD_TIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIH_CHILDREN),
+static WORD_TIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kn"),
         dictgen::InsensitiveStr::Ascii("nk"),
@@ -20985,12 +20985,12 @@ pub static WORD_TIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_TIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIG_CHILDREN),
+static WORD_TIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ger"),
         dictgen::InsensitiveStr::Ascii("gered"),
@@ -21034,12 +21034,12 @@ pub static WORD_TIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIE_CHILDREN),
+static WORD_TIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("breakker"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -21065,12 +21065,12 @@ pub static WORD_TIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_TID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TID_CHILDREN),
+static WORD_TID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TID_CHILDREN),
     value: None,
 };
 
-pub static WORD_TID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibt"),
         dictgen::InsensitiveStr::Ascii("ibts"),
@@ -21080,12 +21080,12 @@ pub static WORD_TID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_TIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIC_CHILDREN),
+static WORD_TIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hened"),
@@ -21101,34 +21101,34 @@ pub static WORD_TIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIB_CHILDREN),
+static WORD_TIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etian")],
     values: &[&["tibetan"]],
     range: 5..=5,
 };
 
-static WORD_TIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TIA_CHILDREN),
+static WORD_TIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("wanese")],
     values: &[&["taiwanese"]],
     range: 6..=6,
 };
 
-static WORD_TH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TH_CHILDREN),
+static WORD_TH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TH_CHILDREN),
     value: None,
 };
 
-static WORD_TH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_THA_NODE),
     None,
     Some(&WORD_THC_NODE),
@@ -21157,12 +21157,12 @@ static WORD_TH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_THY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THY_CHILDREN),
+static WORD_THY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THY_CHILDREN),
     value: None,
 };
 
-pub static WORD_THY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -21173,23 +21173,23 @@ pub static WORD_THY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_THW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THW_CHILDREN),
+static WORD_THW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THW_CHILDREN),
     value: Some(&["the", "thaw"]),
 };
 
-pub static WORD_THW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["the"]],
     range: 1..=1,
 };
 
-static WORD_THU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THU_CHILDREN),
+static WORD_THU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THU_CHILDREN),
     value: None,
 };
 
-pub static WORD_THU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bmnail"),
         dictgen::InsensitiveStr::Ascii("bmnails"),
@@ -21265,12 +21265,12 @@ pub static WORD_THU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_THT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THT_CHILDREN),
+static WORD_THT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THT_CHILDREN),
     value: Some(&["the", "that"]),
 };
 
-pub static WORD_THT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -21280,12 +21280,12 @@ pub static WORD_THT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_THS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THS_CHILDREN),
+static WORD_THS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THS_CHILDREN),
     value: Some(&["the", "this"]),
 };
 
-pub static WORD_THS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -21321,12 +21321,12 @@ pub static WORD_THS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_THR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_THR_CHILDREN),
+static WORD_THR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_THR_CHILDREN),
     value: Some(&["the"]),
 };
 
-static WORD_THR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_THR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_THRA_NODE),
     None,
     None,
@@ -21355,23 +21355,23 @@ static WORD_THR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_THRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRY_CHILDREN),
+static WORD_THRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oid")],
     values: &[&["thyroid"]],
     range: 3..=3,
 };
 
-static WORD_THRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRU_CHILDREN),
+static WORD_THRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("gh"),
@@ -21395,12 +21395,12 @@ pub static WORD_THRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_THRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRR_CHILDREN),
+static WORD_THRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eshold"),
         dictgen::InsensitiveStr::Ascii("esholds"),
@@ -21409,12 +21409,12 @@ pub static WORD_THRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_THRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRO_CHILDREN),
+static WORD_THRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("aths"),
@@ -21504,12 +21504,12 @@ pub static WORD_THRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_THRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRI_CHILDREN),
+static WORD_THRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dly"),
@@ -21527,12 +21527,12 @@ pub static WORD_THRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_THRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRE_CHILDREN),
+static WORD_THRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRE_CHILDREN),
     value: Some(&["three", "there", "their", "the"]),
 };
 
-pub static WORD_THRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adad"),
         dictgen::InsensitiveStr::Ascii("add"),
@@ -21614,12 +21614,12 @@ pub static WORD_THRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_THRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THRA_CHILDREN),
+static WORD_THRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_THRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -21628,23 +21628,23 @@ pub static WORD_THRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_THQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THQ_CHILDREN),
+static WORD_THQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THQ_CHILDREN),
     value: Some(&["the"]),
 };
 
-pub static WORD_THQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_THO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THO_CHILDREN),
+static WORD_THO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THO_CHILDREN),
     value: None,
 };
 
-pub static WORD_THO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecracy"),
         dictgen::InsensitiveStr::Ascii("erem"),
@@ -21770,12 +21770,12 @@ pub static WORD_THO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_THN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THN_CHILDREN),
+static WORD_THN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THN_CHILDREN),
     value: Some(&["then"]),
 };
 
-pub static WORD_THN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ak"),
@@ -21799,23 +21799,23 @@ pub static WORD_THN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_THM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THM_CHILDREN),
+static WORD_THM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THM_CHILDREN),
     value: Some(&["them"]),
 };
 
-pub static WORD_THM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["them"]],
     range: 1..=1,
 };
 
-static WORD_THJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THJ_CHILDREN),
+static WORD_THJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_THJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -21824,12 +21824,12 @@ pub static WORD_THJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_THI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THI_CHILDREN),
+static WORD_THI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THI_CHILDREN),
     value: Some(&["the", "this"]),
 };
 
-pub static WORD_THI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aland"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -21945,12 +21945,12 @@ pub static WORD_THI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_THH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THH_CHILDREN),
+static WORD_THH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THH_CHILDREN),
     value: None,
 };
 
-pub static WORD_THH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -21960,12 +21960,12 @@ pub static WORD_THH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_THG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THG_CHILDREN),
+static WORD_THG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THG_CHILDREN),
     value: None,
 };
 
-pub static WORD_THG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -21974,12 +21974,12 @@ pub static WORD_THG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_THE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_THE_CHILDREN),
+static WORD_THE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_THE_CHILDREN),
     value: None,
 };
 
-static WORD_THE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_THE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_THEA_NODE),
     None,
     None,
@@ -22008,12 +22008,12 @@ static WORD_THE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_THEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEY_CHILDREN),
+static WORD_THEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -22022,34 +22022,34 @@ pub static WORD_THEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_THEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEX_CHILDREN),
+static WORD_THEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEX_CHILDREN),
     value: Some(&["the", "then"]),
 };
 
-pub static WORD_THEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_THEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEV_CHILDREN),
+static WORD_THEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEV_CHILDREN),
     value: Some(&["the"]),
 };
 
-pub static WORD_THEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["thieves"]],
     range: 2..=2,
 };
 
-static WORD_THET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THET_CHILDREN),
+static WORD_THET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THET_CHILDREN),
     value: Some(&["that", "the"]),
 };
 
-pub static WORD_THET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ering"),
         dictgen::InsensitiveStr::Ascii("her"),
@@ -22065,12 +22065,12 @@ pub static WORD_THET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_THES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THES_CHILDREN),
+static WORD_THES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THES_CHILDREN),
     value: Some(&["this", "these", "the"]),
 };
 
-pub static WORD_THES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hold"),
         dictgen::InsensitiveStr::Ascii("holds"),
@@ -22090,12 +22090,12 @@ pub static WORD_THES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_THER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_THER_CHILDREN),
+static WORD_THER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_THER_CHILDREN),
     value: Some(&["there", "their", "the", "other"]),
 };
 
-static WORD_THER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_THER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_THERA_NODE),
     Some(&WORD_THERB_NODE),
     None,
@@ -22124,23 +22124,23 @@ static WORD_THER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_THERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERW_CHILDREN),
+static WORD_THERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ise")],
     values: &[&["otherwise"]],
     range: 3..=3,
 };
 
-static WORD_THERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERS_CHILDREN),
+static WORD_THERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hold"),
         dictgen::InsensitiveStr::Ascii("tat"),
@@ -22149,12 +22149,12 @@ pub static WORD_THERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_THERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERO_CHILDREN),
+static WORD_THERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("em"),
         dictgen::InsensitiveStr::Ascii("etical"),
@@ -22184,23 +22184,23 @@ pub static WORD_THERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_THERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERN_CHILDREN),
+static WORD_THERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("odynamics")],
     values: &[&["thermodynamics"]],
     range: 9..=9,
 };
 
-static WORD_THERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERM_CHILDREN),
+static WORD_THERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("astat"),
         dictgen::InsensitiveStr::Ascii("isor"),
@@ -22256,12 +22256,12 @@ pub static WORD_THERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_THERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERI_CHILDREN),
+static WORD_THERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERI_CHILDREN),
     value: Some(&["their", "there"]),
 };
 
-pub static WORD_THERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("pists"),
@@ -22270,23 +22270,23 @@ pub static WORD_THERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_THERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERF_CHILDREN),
+static WORD_THERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ore")],
     values: &[&["therefore"]],
     range: 3..=3,
 };
 
-static WORD_THERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERE_CHILDREN),
+static WORD_THERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("ads"),
@@ -22326,23 +22326,23 @@ pub static WORD_THERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_THERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERB_CHILDREN),
+static WORD_THERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["thereby"]],
     range: 1..=1,
 };
 
-static WORD_THERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THERA_CHILDREN),
+static WORD_THERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_THERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fter"),
         dictgen::InsensitiveStr::Ascii("min"),
@@ -22374,12 +22374,12 @@ pub static WORD_THERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_THEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEO_CHILDREN),
+static WORD_THEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cracry"),
         dictgen::InsensitiveStr::Ascii("ligical"),
@@ -22429,12 +22429,12 @@ pub static WORD_THEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_THEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEN_CHILDREN),
+static WORD_THEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -22443,12 +22443,12 @@ pub static WORD_THEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_THEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEM_CHILDREN),
+static WORD_THEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eselves"),
         dictgen::InsensitiveStr::Ascii("plate"),
@@ -22484,12 +22484,12 @@ pub static WORD_THEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_THEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEI_CHILDREN),
+static WORD_THEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEI_CHILDREN),
     value: Some(&["their", "they"]),
 };
 
-pub static WORD_THEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("f"),
@@ -22519,23 +22519,23 @@ pub static WORD_THEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_THEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEF_CHILDREN),
+static WORD_THEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ore")],
     values: &[&["therefore"]],
     range: 3..=3,
 };
 
-static WORD_THEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEE_CHILDREN),
+static WORD_THEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -22546,12 +22546,12 @@ pub static WORD_THEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_THEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THEA_CHILDREN),
+static WORD_THEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_THEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -22581,23 +22581,23 @@ pub static WORD_THEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_THC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THC_CHILDREN),
+static WORD_THC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THC_CHILDREN),
     value: None,
 };
 
-pub static WORD_THC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["thick"]],
     range: 1..=1,
 };
 
-static WORD_THA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_THA_CHILDREN),
+static WORD_THA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_THA_CHILDREN),
     value: Some(&["than", "that", "the"]),
 };
 
-pub static WORD_THA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_THA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -22657,12 +22657,12 @@ pub static WORD_THA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TG_CHILDREN),
+static WORD_TG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -22672,12 +22672,12 @@ pub static WORD_TG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_TE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TE_CHILDREN),
+static WORD_TE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TE_CHILDREN),
     value: None,
 };
 
-static WORD_TE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TEA_NODE),
     None,
     Some(&WORD_TEC_NODE),
@@ -22706,23 +22706,23 @@ static WORD_TE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEY_CHILDREN),
+static WORD_TEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEY_CHILDREN),
     value: Some(&["they"]),
 };
 
-pub static WORD_TEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_TEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEX_CHILDREN),
+static WORD_TEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chnically"),
         dictgen::InsensitiveStr::Ascii("line"),
@@ -22762,12 +22762,12 @@ pub static WORD_TEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_TEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEU_CHILDREN),
+static WORD_TEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sday"),
         dictgen::InsensitiveStr::Ascii("sdays"),
@@ -22776,12 +22776,12 @@ pub static WORD_TEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_TET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TET_CHILDREN),
+static WORD_TET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TET_CHILDREN),
     value: None,
 };
 
-pub static WORD_TET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rahedora"),
         dictgen::InsensitiveStr::Ascii("rahedoren"),
@@ -22809,12 +22809,12 @@ pub static WORD_TET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_TES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TES_CHILDREN),
+static WORD_TES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TES_CHILDREN),
     value: None,
 };
 
-pub static WORD_TES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("case"),
         dictgen::InsensitiveStr::Ascii("cases"),
@@ -22902,12 +22902,12 @@ pub static WORD_TES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_TER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TER_CHILDREN),
+static WORD_TER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TER_CHILDREN),
     value: None,
 };
 
-static WORD_TER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TERA_NODE),
     None,
     None,
@@ -22936,12 +22936,12 @@ static WORD_TER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERU_CHILDREN),
+static WORD_TERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rn"),
         dictgen::InsensitiveStr::Ascii("rns"),
@@ -22950,12 +22950,12 @@ pub static WORD_TERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_TERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERR_CHILDREN),
+static WORD_TERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("abyte"),
@@ -23057,12 +23057,12 @@ pub static WORD_TERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_TERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERO_CHILDREN),
+static WORD_TERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rrism"),
         dictgen::InsensitiveStr::Ascii("rrist"),
@@ -23072,12 +23072,12 @@ pub static WORD_TERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERN_CHILDREN),
+static WORD_TERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ament"),
         dictgen::InsensitiveStr::Ascii("imate"),
@@ -23093,12 +23093,12 @@ pub static WORD_TERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_TERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TERM_CHILDREN),
+static WORD_TERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TERM_CHILDREN),
     value: None,
 };
 
-static WORD_TERM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TERM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TERMA_NODE),
     None,
     None,
@@ -23127,12 +23127,12 @@ static WORD_TERM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TERMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMP_CHILDREN),
+static WORD_TERMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eratue"),
         dictgen::InsensitiveStr::Ascii("eratues"),
@@ -23162,12 +23162,12 @@ pub static WORD_TERMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_TERMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMO_CHILDREN),
+static WORD_TERMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMO_CHILDREN),
     value: Some(&["thermo"]),
 };
 
-pub static WORD_TERMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nology"),
         dictgen::InsensitiveStr::Ascii("stat"),
@@ -23176,12 +23176,12 @@ pub static WORD_TERMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_TERMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMN_CHILDREN),
+static WORD_TERMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ator"),
         dictgen::InsensitiveStr::Ascii("ials"),
@@ -23211,12 +23211,12 @@ pub static WORD_TERMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_TERMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMI_CHILDREN),
+static WORD_TERMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("als"),
@@ -23300,12 +23300,12 @@ pub static WORD_TERMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TERME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERME_CHILDREN),
+static WORD_TERME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERME_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndous"),
         dictgen::InsensitiveStr::Ascii("ndously"),
@@ -23314,12 +23314,12 @@ pub static WORD_TERME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TERMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERMA_CHILDREN),
+static WORD_TERMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nator"),
         dictgen::InsensitiveStr::Ascii("nology"),
@@ -23328,12 +23328,12 @@ pub static WORD_TERMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERI_CHILDREN),
+static WORD_TERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dactyl"),
         dictgen::InsensitiveStr::Ascii("fic"),
@@ -23353,12 +23353,12 @@ pub static WORD_TERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_TERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERF_CHILDREN),
+static WORD_TERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("formed"),
@@ -23374,23 +23374,23 @@ pub static WORD_TERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_TERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERE_CHILDREN),
+static WORD_TERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERE_CHILDREN),
     value: Some(&["there", "here"]),
 };
 
-pub static WORD_TERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_TERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TERA_CHILDREN),
+static WORD_TERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("formed"),
@@ -23408,12 +23408,12 @@ pub static WORD_TERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_TEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEQ_CHILDREN),
+static WORD_TEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uests"),
         dictgen::InsensitiveStr::Ascii("uilia"),
@@ -23423,12 +23423,12 @@ pub static WORD_TEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_TEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEP_CHILDREN),
+static WORD_TEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lmate"),
         dictgen::InsensitiveStr::Ascii("lmated"),
@@ -23446,23 +23446,23 @@ pub static WORD_TEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_TEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEO_CHILDREN),
+static WORD_TEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rem")],
     values: &[&["theorem"]],
     range: 3..=3,
 };
 
-static WORD_TEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEN_CHILDREN),
+static WORD_TEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acitiy"),
         dictgen::InsensitiveStr::Ascii("acle"),
@@ -23544,12 +23544,12 @@ pub static WORD_TEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_TEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TEM_CHILDREN),
+static WORD_TEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TEM_CHILDREN),
     value: None,
 };
 
-static WORD_TEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TEM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TEMA_NODE),
     None,
     None,
@@ -23578,45 +23578,45 @@ static WORD_TEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TEMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMT_CHILDREN),
+static WORD_TEMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["temptation"]],
     range: 5..=5,
 };
 
-static WORD_TEMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMS_CHILDREN),
+static WORD_TEMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("elves")],
     values: &[&["themselves"]],
     range: 5..=5,
 };
 
-static WORD_TEMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMR_CHILDREN),
+static WORD_TEMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMR_CHILDREN),
     value: Some(&["term"]),
 };
 
-pub static WORD_TEMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inal")],
     values: &[&["terminal"]],
     range: 4..=4,
 };
 
-static WORD_TEMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TEMP_CHILDREN),
+static WORD_TEMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TEMP_CHILDREN),
     value: None,
 };
 
-static WORD_TEMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TEMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TEMPA_NODE),
     None,
     None,
@@ -23645,12 +23645,12 @@ static WORD_TEMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TEMPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPU_CHILDREN),
+static WORD_TEMPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rature"),
         dictgen::InsensitiveStr::Ascii("ratures"),
@@ -23660,12 +23660,12 @@ pub static WORD_TEMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TEMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPT_CHILDREN),
+static WORD_TEMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atation"),
         dictgen::InsensitiveStr::Ascii("ating"),
@@ -23681,23 +23681,23 @@ pub static WORD_TEMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_TEMPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPS_CHILDREN),
+static WORD_TEMPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["tempest"]],
     range: 2..=2,
 };
 
-static WORD_TEMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPR_CHILDREN),
+static WORD_TEMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aaily"),
         dictgen::InsensitiveStr::Ascii("aal"),
@@ -23797,12 +23797,12 @@ pub static WORD_TEMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TEMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPO_CHILDREN),
+static WORD_TEMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aray"),
         dictgen::InsensitiveStr::Ascii("pary"),
@@ -23898,12 +23898,12 @@ pub static WORD_TEMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_TEMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPL_CHILDREN),
+static WORD_TEMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aced"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -23949,12 +23949,12 @@ pub static WORD_TEMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_TEMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPE_CHILDREN),
+static WORD_TEMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arture"),
         dictgen::InsensitiveStr::Ascii("artures"),
@@ -24008,23 +24008,23 @@ pub static WORD_TEMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TEMPD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPD_CHILDREN),
+static WORD_TEMPD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ate")],
     values: &[&["template"]],
     range: 3..=3,
 };
 
-static WORD_TEMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMPA_CHILDREN),
+static WORD_TEMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lrs"),
         dictgen::InsensitiveStr::Ascii("lte"),
@@ -24074,12 +24074,12 @@ pub static WORD_TEMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TEMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMO_CHILDREN),
+static WORD_TEMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rarily"),
         dictgen::InsensitiveStr::Ascii("rary"),
@@ -24088,34 +24088,34 @@ pub static WORD_TEMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_TEMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMM_CHILDREN),
+static WORD_TEMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("porary")],
     values: &[&["temporary", "temporarily"]],
     range: 6..=6,
 };
 
-static WORD_TEML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEML_CHILDREN),
+static WORD_TEML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEML_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ate")],
     values: &[&["template"]],
     range: 3..=3,
 };
 
-static WORD_TEMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMI_CHILDREN),
+static WORD_TEMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nal"),
         dictgen::InsensitiveStr::Ascii("nals"),
@@ -24137,12 +24137,12 @@ pub static WORD_TEMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_TEME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEME_CHILDREN),
+static WORD_TEME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEME_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("prature"),
         dictgen::InsensitiveStr::Ascii("pratures"),
@@ -24158,12 +24158,12 @@ pub static WORD_TEME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_TEMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEMA_CHILDREN),
+static WORD_TEMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEMA_CHILDREN),
     value: Some(&["team"]),
 };
 
-pub static WORD_TEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fight"),
         dictgen::InsensitiveStr::Ascii("fights"),
@@ -24179,12 +24179,12 @@ pub static WORD_TEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEL_CHILDREN),
+static WORD_TEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aportation"),
         dictgen::InsensitiveStr::Ascii("egrah"),
@@ -24248,12 +24248,12 @@ pub static WORD_TEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_TEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEK_CHILDREN),
+static WORD_TEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("st"),
@@ -24263,12 +24263,12 @@ pub static WORD_TEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_TEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEH_CHILDREN),
+static WORD_TEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEH_CHILDREN),
     value: Some(&["the"]),
 };
 
-pub static WORD_TEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cies"),
         dictgen::InsensitiveStr::Ascii("ere"),
@@ -24298,34 +24298,34 @@ pub static WORD_TEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEG_CHILDREN),
+static WORD_TEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ister")],
     values: &[&["register"]],
     range: 5..=5,
 };
 
-static WORD_TEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEF_CHILDREN),
+static WORD_TEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ine")],
     values: &[&["define"]],
     range: 3..=3,
 };
 
-static WORD_TEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEE_CHILDREN),
+static WORD_TEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angers"),
         dictgen::InsensitiveStr::Ascii("nages"),
@@ -24343,23 +24343,23 @@ pub static WORD_TEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_TED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TED_CHILDREN),
+static WORD_TED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TED_CHILDREN),
     value: None,
 };
 
-pub static WORD_TED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eous")],
     values: &[&["tedious"]],
     range: 4..=4,
 };
 
-static WORD_TEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TEC_CHILDREN),
+static WORD_TEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TEC_CHILDREN),
     value: None,
 };
 
-static WORD_TEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -24388,23 +24388,23 @@ static WORD_TEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECT_CHILDREN),
+static WORD_TECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECT_CHILDREN),
     value: Some(&["test", "text"]),
 };
 
-pub static WORD_TECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ure")],
     values: &[&["texture"]],
     range: 3..=3,
 };
 
-static WORD_TECN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECN_CHILDREN),
+static WORD_TECN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -24428,12 +24428,12 @@ pub static WORD_TECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_TECH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TECH_CHILDREN),
+static WORD_TECH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TECH_CHILDREN),
     value: None,
 };
 
-static WORD_TECH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TECH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_TECHA_NODE),
     None,
     None,
@@ -24462,12 +24462,12 @@ static WORD_TECH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TECHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHT_CHILDREN),
+static WORD_TECHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ician"),
         dictgen::InsensitiveStr::Ascii("icians"),
@@ -24476,12 +24476,12 @@ pub static WORD_TECHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_TECHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHO_CHILDREN),
+static WORD_TECHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logy"),
         dictgen::InsensitiveStr::Ascii("nlogical"),
@@ -24491,12 +24491,12 @@ pub static WORD_TECHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_TECHN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHN_CHILDREN),
+static WORD_TECHN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cially"),
         dictgen::InsensitiveStr::Ascii("eek"),
@@ -24582,23 +24582,23 @@ pub static WORD_TECHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_TECHM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHM_CHILDREN),
+static WORD_TECHM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ological")],
     values: &[&["technological"]],
     range: 8..=8,
 };
 
-static WORD_TECHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHI_CHILDREN),
+static WORD_TECHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("cally"),
@@ -24644,12 +24644,12 @@ pub static WORD_TECHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_TECHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHE_CHILDREN),
+static WORD_TECHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("is"),
@@ -24667,23 +24667,23 @@ pub static WORD_TECHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_TECHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TECHA_CHILDREN),
+static WORD_TECHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TECHA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TECHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TECHA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nically")],
     values: &[&["mechanically"]],
     range: 7..=7,
 };
 
-static WORD_TEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TEA_CHILDREN),
+static WORD_TEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_TEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cer"),
         dictgen::InsensitiveStr::Ascii("cers"),
@@ -24751,12 +24751,12 @@ pub static WORD_TEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_TD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TD_CHILDREN),
+static WORD_TD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TD_CHILDREN),
     value: None,
 };
 
-pub static WORD_TD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("od"),
         dictgen::InsensitiveStr::Ascii("oo"),
@@ -24765,12 +24765,12 @@ pub static WORD_TD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_TC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TC_CHILDREN),
+static WORD_TC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahce"),
         dictgen::InsensitiveStr::Ascii("ahces"),
@@ -24790,12 +24790,12 @@ pub static WORD_TC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_TB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TB_CHILDREN),
+static WORD_TB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ey"),
@@ -24804,12 +24804,12 @@ pub static WORD_TB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_TA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_TA_CHILDREN),
+static WORD_TA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_TA_CHILDREN),
     value: None,
 };
 
-static WORD_TA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_TA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_TAB_NODE),
     Some(&WORD_TAC_NODE),
@@ -24838,23 +24838,23 @@ static WORD_TA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_TAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAY_CHILDREN),
+static WORD_TAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lored")],
     values: &[&["tailored"]],
     range: 5..=5,
 };
 
-static WORD_TAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAX_CHILDREN),
+static WORD_TAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anomic"),
         dictgen::InsensitiveStr::Ascii("anomy"),
@@ -24874,12 +24874,12 @@ pub static WORD_TAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_TAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAW_CHILDREN),
+static WORD_TAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainese"),
         dictgen::InsensitiveStr::Ascii("ianese"),
@@ -24889,12 +24889,12 @@ pub static WORD_TAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_TAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAV_CHILDREN),
+static WORD_TAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -24910,12 +24910,12 @@ pub static WORD_TAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_TAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAT_CHILDREN),
+static WORD_TAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gert"),
         dictgen::InsensitiveStr::Ascii("gerted"),
@@ -24943,12 +24943,12 @@ pub static WORD_TAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_TAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAS_CHILDREN),
+static WORD_TAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bar"),
         dictgen::InsensitiveStr::Ascii("kelt"),
@@ -24964,12 +24964,12 @@ pub static WORD_TAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAR_CHILDREN),
+static WORD_TAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bal"),
         dictgen::InsensitiveStr::Ascii("bals"),
@@ -25033,23 +25033,23 @@ pub static WORD_TAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAP_CHILDREN),
+static WORD_TAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itude")],
     values: &[&["aptitude"]],
     range: 5..=5,
 };
 
-static WORD_TAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAN_CHILDREN),
+static WORD_TAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enhill"),
         dictgen::InsensitiveStr::Ascii("geant"),
@@ -25131,12 +25131,12 @@ pub static WORD_TAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_TAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAM_CHILDREN),
+static WORD_TAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("plate"),
         dictgen::InsensitiveStr::Ascii("plated"),
@@ -25152,12 +25152,12 @@ pub static WORD_TAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_TAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAL_CHILDREN),
+static WORD_TAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("bian"),
@@ -25187,12 +25187,12 @@ pub static WORD_TAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_TAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAK_CHILDREN),
+static WORD_TAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAK_CHILDREN),
     value: Some(&["take"]),
 };
 
-pub static WORD_TAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -25210,12 +25210,12 @@ pub static WORD_TAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_TAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAI_CHILDREN),
+static WORD_TAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lban"),
         dictgen::InsensitiveStr::Ascii("lgateing"),
@@ -25241,12 +25241,12 @@ pub static WORD_TAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_TAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAH_CHILDREN),
+static WORD_TAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nk"),
@@ -25258,12 +25258,12 @@ pub static WORD_TAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_TAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAG_CHILDREN),
+static WORD_TAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -25303,12 +25303,12 @@ pub static WORD_TAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_TAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAC_CHILDREN),
+static WORD_TAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itcally"),
         dictgen::InsensitiveStr::Ascii("ticallity"),
@@ -25328,12 +25328,12 @@ pub static WORD_TAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_TAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_TAB_CHILDREN),
+static WORD_TAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_TAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_TAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_TAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acco"),
         dictgen::InsensitiveStr::Ascii("baray"),
@@ -25411,12 +25411,12 @@ pub static WORD_TAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_S_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_S_CHILDREN),
+static WORD_S_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_S_CHILDREN),
     value: None,
 };
 
-static WORD_S_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_S_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SA_NODE),
     Some(&WORD_SB_NODE),
     Some(&WORD_SC_NODE),
@@ -25445,12 +25445,12 @@ static WORD_S_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SZ_NODE),
 ];
 
-static WORD_SZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SZ_CHILDREN),
+static WORD_SZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enario"),
         dictgen::InsensitiveStr::Ascii("enarios"),
@@ -25470,12 +25470,12 @@ pub static WORD_SZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SY_CHILDREN),
+static WORD_SY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SY_CHILDREN),
     value: None,
 };
 
-static WORD_SY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SY_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SYA_NODE),
     Some(&WORD_SYB_NODE),
     Some(&WORD_SYC_NODE),
@@ -25504,12 +25504,12 @@ static WORD_SY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SYT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYT_CHILDREN),
+static WORD_SYT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actical"),
         dictgen::InsensitiveStr::Ascii("ax"),
@@ -25573,12 +25573,12 @@ pub static WORD_SYT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SYS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYS_CHILDREN),
+static WORD_SYS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("admn"),
         dictgen::InsensitiveStr::Ascii("amdin"),
@@ -25676,12 +25676,12 @@ pub static WORD_SYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_SYR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYR_CHILDREN),
+static WORD_SYR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acue"),
         dictgen::InsensitiveStr::Ascii("acusae"),
@@ -25705,12 +25705,12 @@ pub static WORD_SYR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SYP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYP_CHILDREN),
+static WORD_SYP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hyllis"),
         dictgen::InsensitiveStr::Ascii("mathetic"),
@@ -25734,12 +25734,12 @@ pub static WORD_SYP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_SYN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SYN_CHILDREN),
+static WORD_SYN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SYN_CHILDREN),
     value: None,
 };
 
-static WORD_SYN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SYN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SYNA_NODE),
     Some(&WORD_SYNB_NODE),
     Some(&WORD_SYNC_NODE),
@@ -25768,12 +25768,12 @@ static WORD_SYN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SYNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNT_CHILDREN),
+static WORD_SYNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ac"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -25861,23 +25861,23 @@ pub static WORD_SYNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SYNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNR_CHILDREN),
+static WORD_SYNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onous")],
     values: &[&["synchronous"]],
     range: 5..=5,
 };
 
-static WORD_SYNP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNP_CHILDREN),
+static WORD_SYNP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hony"),
         dictgen::InsensitiveStr::Ascii("osis"),
@@ -25886,12 +25886,12 @@ pub static WORD_SYNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_SYNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNO_CHILDREN),
+static WORD_SYNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mym"),
         dictgen::InsensitiveStr::Ascii("mymous"),
@@ -25947,34 +25947,34 @@ pub static WORD_SYNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SYNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNI_CHILDREN),
+static WORD_SYNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dcate")],
     values: &[&["syndicate"]],
     range: 5..=5,
 };
 
-static WORD_SYNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNE_CHILDREN),
+static WORD_SYNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gry")],
     values: &[&["synergy"]],
     range: 3..=3,
 };
 
-static WORD_SYND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYND_CHILDREN),
+static WORD_SYND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYND_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acite"),
         dictgen::InsensitiveStr::Ascii("iacte"),
@@ -25992,12 +25992,12 @@ pub static WORD_SYND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SYNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNC_CHILDREN),
+static WORD_SYNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("honisation"),
         dictgen::InsensitiveStr::Ascii("honise"),
@@ -26115,23 +26115,23 @@ pub static WORD_SYNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_SYNB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNB_CHILDREN),
+static WORD_SYNB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olic")],
     values: &[&["symbolic"]],
     range: 4..=4,
 };
 
-static WORD_SYNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYNA_CHILDREN),
+static WORD_SYNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gouge"),
         dictgen::InsensitiveStr::Ascii("mic"),
@@ -26149,12 +26149,12 @@ pub static WORD_SYNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SYM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SYM_CHILDREN),
+static WORD_SYM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SYM_CHILDREN),
     value: None,
 };
 
-static WORD_SYM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SYM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SYMA_NODE),
     Some(&WORD_SYMB_NODE),
     None,
@@ -26183,12 +26183,12 @@ static WORD_SYM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SYMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMT_CHILDREN),
+static WORD_SYMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oms"),
         dictgen::InsensitiveStr::Ascii("pom"),
@@ -26198,12 +26198,12 @@ pub static WORD_SYMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SYMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMP_CHILDREN),
+static WORD_SYMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("athatic"),
         dictgen::InsensitiveStr::Ascii("atheic"),
@@ -26291,12 +26291,12 @@ pub static WORD_SYMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_SYMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMO_CHILDREN),
+static WORD_SYMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilic"),
         dictgen::InsensitiveStr::Ascii("bl"),
@@ -26324,12 +26324,12 @@ pub static WORD_SYMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SYMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMN_CHILDREN),
+static WORD_SYMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ol"),
         dictgen::InsensitiveStr::Ascii("ols"),
@@ -26338,12 +26338,12 @@ pub static WORD_SYMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SYMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMM_CHILDREN),
+static WORD_SYMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ertical"),
         dictgen::InsensitiveStr::Ascii("erty"),
@@ -26369,23 +26369,23 @@ pub static WORD_SYMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SYMH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMH_CHILDREN),
+static WORD_SYMH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pony")],
     values: &[&["symphony"]],
     range: 4..=4,
 };
 
-static WORD_SYME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYME_CHILDREN),
+static WORD_SYME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYME_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("metric"),
         dictgen::InsensitiveStr::Ascii("tri"),
@@ -26407,12 +26407,12 @@ pub static WORD_SYME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SYMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMB_CHILDREN),
+static WORD_SYMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("les"),
@@ -26446,12 +26446,12 @@ pub static WORD_SYMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SYMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYMA_CHILDREN),
+static WORD_SYMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntic"),
         dictgen::InsensitiveStr::Ascii("ntics"),
@@ -26471,12 +26471,12 @@ pub static WORD_SYMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_SYL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYL_CHILDREN),
+static WORD_SYL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ablle"),
         dictgen::InsensitiveStr::Ascii("ablles"),
@@ -26514,12 +26514,12 @@ pub static WORD_SYL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SYK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYK_CHILDREN),
+static WORD_SYK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("walker"),
         dictgen::InsensitiveStr::Ascii("ward"),
@@ -26528,34 +26528,34 @@ pub static WORD_SYK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_SYI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYI_CHILDREN),
+static WORD_SYI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rans")],
     values: &[&["syrians"]],
     range: 4..=4,
 };
 
-static WORD_SYF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYF_CHILDREN),
+static WORD_SYF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["sysfs"]],
     range: 1..=1,
 };
 
-static WORD_SYD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYD_CHILDREN),
+static WORD_SYD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nicate"),
         dictgen::InsensitiveStr::Ascii("nrome"),
@@ -26564,12 +26564,12 @@ pub static WORD_SYD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_SYC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYC_CHILDREN),
+static WORD_SYC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hnronization"),
         dictgen::InsensitiveStr::Ascii("hronisation"),
@@ -26655,12 +26655,12 @@ pub static WORD_SYC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_SYB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYB_CHILDREN),
+static WORD_SYB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mols"),
         dictgen::InsensitiveStr::Ascii("system"),
@@ -26670,12 +26670,12 @@ pub static WORD_SYB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SYA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SYA_CHILDREN),
+static WORD_SYA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SYA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SYA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SYA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntax"),
         dictgen::InsensitiveStr::Ascii("rcuse"),
@@ -26693,12 +26693,12 @@ pub static WORD_SYA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SX_CHILDREN),
+static WORD_SX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("mbol"),
@@ -26709,12 +26709,12 @@ pub static WORD_SX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SW_CHILDREN),
+static WORD_SW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SW_CHILDREN),
     value: None,
 };
 
-static WORD_SW_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SW_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SWA_NODE),
     None,
     Some(&WORD_SWC_NODE),
@@ -26743,12 +26743,12 @@ static WORD_SW_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SWT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWT_CHILDREN),
+static WORD_SWT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ich"),
         dictgen::InsensitiveStr::Ascii("ichable"),
@@ -26784,34 +26784,34 @@ pub static WORD_SWT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SWO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWO_CHILDREN),
+static WORD_SWO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("wn")],
     values: &[&["shown"]],
     range: 2..=2,
 };
 
-static WORD_SWN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWN_CHILDREN),
+static WORD_SWN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("asea")],
     values: &[&["swansea"]],
     range: 4..=4,
 };
 
-static WORD_SWI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWI_CHILDREN),
+static WORD_SWI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -26895,12 +26895,12 @@ pub static WORD_SWI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SWE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWE_CHILDREN),
+static WORD_SWE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arengin"),
         dictgen::InsensitiveStr::Ascii("arshirt"),
@@ -26934,23 +26934,23 @@ pub static WORD_SWE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_SWC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWC_CHILDREN),
+static WORD_SWC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("loumns")],
     values: &[&["swcolumns"]],
     range: 6..=6,
 };
 
-static WORD_SWA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SWA_CHILDREN),
+static WORD_SWA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SWA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SWA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SWA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ering"),
@@ -26990,12 +26990,12 @@ pub static WORD_SWA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SV_CHILDREN),
+static WORD_SV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("elt"),
@@ -27004,12 +27004,12 @@ pub static WORD_SV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_SU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SU_CHILDREN),
+static WORD_SU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SU_CHILDREN),
     value: None,
 };
 
-static WORD_SU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SUA_NODE),
     Some(&WORD_SUB_NODE),
     Some(&WORD_SUC_NODE),
@@ -27038,12 +27038,12 @@ static WORD_SU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUY_CHILDREN),
+static WORD_SUY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stem"),
         dictgen::InsensitiveStr::Ascii("stemic"),
@@ -27053,12 +27053,12 @@ pub static WORD_SUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_SUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUV_CHILDREN),
+static WORD_SUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enear"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -27067,12 +27067,12 @@ pub static WORD_SUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUU_CHILDREN),
+static WORD_SUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("port"),
         dictgen::InsensitiveStr::Ascii("ported"),
@@ -27083,12 +27083,12 @@ pub static WORD_SUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUT_CHILDREN),
+static WORD_SUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("down"),
@@ -27126,12 +27126,12 @@ pub static WORD_SUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_SUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUS_CHILDREN),
+static WORD_SUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUS_CHILDREN),
     value: None,
 };
 
-static WORD_SUS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SUSB_NODE),
     Some(&WORD_SUSC_NODE),
@@ -27160,23 +27160,23 @@ static WORD_SUS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSU_CHILDREN),
+static WORD_SUSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pend")],
     values: &[&["suspend"]],
     range: 4..=4,
 };
 
-static WORD_SUST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUST_CHILDREN),
+static WORD_SUST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUST_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainabillity"),
         dictgen::InsensitiveStr::Ascii("ainabiltiy"),
@@ -27206,12 +27206,12 @@ pub static WORD_SUST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_SUSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSS_CHILDREN),
+static WORD_SUSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eed"),
         dictgen::InsensitiveStr::Ascii("eeded"),
@@ -27233,12 +27233,12 @@ pub static WORD_SUSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SUSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSP_CHILDREN),
+static WORD_SUSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciously"),
         dictgen::InsensitiveStr::Ascii("ecions"),
@@ -27324,23 +27324,23 @@ pub static WORD_SUSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUSN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSN_CHILDREN),
+static WORD_SUSN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("creen")],
     values: &[&["sunscreen"]],
     range: 5..=5,
 };
 
-static WORD_SUSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSI_CHILDREN),
+static WORD_SUSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nct"),
         dictgen::InsensitiveStr::Ascii("nctly"),
@@ -27350,12 +27350,12 @@ pub static WORD_SUSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SUSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSE_CHILDREN),
+static WORD_SUSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cptible"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -27387,12 +27387,12 @@ pub static WORD_SUSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SUSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSC_CHILDREN),
+static WORD_SUSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ede"),
         dictgen::InsensitiveStr::Ascii("eded"),
@@ -27430,12 +27430,12 @@ pub static WORD_SUSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUSB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUSB_CHILDREN),
+static WORD_SUSB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUSB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUSB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cribe"),
         dictgen::InsensitiveStr::Ascii("cribed"),
@@ -27463,12 +27463,12 @@ pub static WORD_SUSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_SUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUR_CHILDREN),
+static WORD_SUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUR_CHILDREN),
     value: Some(&["sure"]),
 };
 
-static WORD_SUR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SURB_NODE),
     None,
@@ -27497,12 +27497,12 @@ static WORD_SUR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SURV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURV_CHILDREN),
+static WORD_SURV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aillance"),
         dictgen::InsensitiveStr::Ascii("aillence"),
@@ -27576,12 +27576,12 @@ pub static WORD_SURV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SURR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURR_CHILDREN),
+static WORD_SURR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egat"),
         dictgen::InsensitiveStr::Ascii("ended"),
@@ -27643,12 +27643,12 @@ pub static WORD_SURR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_SURP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURP_CHILDREN),
+static WORD_SURP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ases"),
         dictgen::InsensitiveStr::Ascii("emacist"),
@@ -27696,12 +27696,12 @@ pub static WORD_SURP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SURO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURO_CHILDREN),
+static WORD_SURO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("und"),
         dictgen::InsensitiveStr::Ascii("unded"),
@@ -27719,23 +27719,23 @@ pub static WORD_SURO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SURL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURL_CHILDREN),
+static WORD_SURL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ey")],
     values: &[&["surly", "surely"]],
     range: 2..=2,
 };
 
-static WORD_SURG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURG_CHILDREN),
+static WORD_SURG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ested"),
@@ -27757,12 +27757,12 @@ pub static WORD_SURG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SURF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURF_CHILDREN),
+static WORD_SURF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aec"),
         dictgen::InsensitiveStr::Ascii("cae"),
@@ -27772,23 +27772,23 @@ pub static WORD_SURF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SURE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURE_CHILDREN),
+static WORD_SURE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("vy")],
     values: &[&["survey"]],
     range: 2..=2,
 };
 
-static WORD_SURB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SURB_CHILDREN),
+static WORD_SURB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SURB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SURB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SURB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ert"),
         dictgen::InsensitiveStr::Ascii("uban"),
@@ -27797,12 +27797,12 @@ pub static WORD_SURB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUP_CHILDREN),
+static WORD_SUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUP_CHILDREN),
     value: None,
 };
 
-static WORD_SUP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -27831,12 +27831,12 @@ static WORD_SUP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPS_CHILDREN),
+static WORD_SUPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cription"),
         dictgen::InsensitiveStr::Ascii("criptions"),
@@ -27874,12 +27874,12 @@ pub static WORD_SUPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SUPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPR_CHILDREN),
+static WORD_SUPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amacist"),
         dictgen::InsensitiveStr::Ascii("ass"),
@@ -27957,12 +27957,12 @@ pub static WORD_SUPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SUPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUPP_CHILDREN),
+static WORD_SUPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUPP_CHILDREN),
     value: None,
 };
 
-static WORD_SUPP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUPP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -27991,23 +27991,23 @@ static WORD_SUPP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUPPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPY_CHILDREN),
+static WORD_SUPPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPY_CHILDREN),
     value: Some(&["supply"]),
 };
 
-pub static WORD_SUPPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["supplying"]],
     range: 3..=3,
 };
 
-static WORD_SUPPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPU_CHILDREN),
+static WORD_SUPPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rt"),
         dictgen::InsensitiveStr::Ascii("rted"),
@@ -28029,12 +28029,12 @@ pub static WORD_SUPPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SUPPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPR_CHILDREN),
+static WORD_SUPPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("esed"),
@@ -28092,12 +28092,12 @@ pub static WORD_SUPPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SUPPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPP_CHILDREN),
+static WORD_SUPPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lied"),
         dictgen::InsensitiveStr::Ascii("ored"),
@@ -28123,12 +28123,12 @@ pub static WORD_SUPPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SUPPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPO_CHILDREN),
+static WORD_SUPPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ert"),
@@ -28220,12 +28220,12 @@ pub static WORD_SUPPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SUPPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPL_CHILDREN),
+static WORD_SUPPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ament"),
         dictgen::InsensitiveStr::Ascii("amental"),
@@ -28263,12 +28263,12 @@ pub static WORD_SUPPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SUPPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPI_CHILDREN),
+static WORD_SUPPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -28278,12 +28278,12 @@ pub static WORD_SUPPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=2,
 };
 
-static WORD_SUPPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPPE_CHILDREN),
+static WORD_SUPPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rssor"),
         dictgen::InsensitiveStr::Ascii("rt"),
@@ -28293,12 +28293,12 @@ pub static WORD_SUPPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SUPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPO_CHILDREN),
+static WORD_SUPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("orted"),
@@ -28346,12 +28346,12 @@ pub static WORD_SUPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SUPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPL_CHILDREN),
+static WORD_SUPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("anted"),
@@ -28379,34 +28379,34 @@ pub static WORD_SUPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPI_CHILDREN),
+static WORD_SUPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rsed")],
     values: &[&["surprised"]],
     range: 4..=4,
 };
 
-static WORD_SUPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPH_CHILDREN),
+static WORD_SUPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("isticated")],
     values: &[&["sophisticated"]],
     range: 9..=9,
 };
 
-static WORD_SUPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUPE_CHILDREN),
+static WORD_SUPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUPE_CHILDREN),
     value: None,
 };
 
-static WORD_SUPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SUPEB_NODE),
     Some(&WORD_SUPEC_NODE),
@@ -28435,12 +28435,12 @@ static WORD_SUPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUPER_CHILDREN),
+static WORD_SUPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUPER_CHILDREN),
     value: None,
 };
 
-static WORD_SUPER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUPER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SUPERB_NODE),
     Some(&WORD_SUPERC_NODE),
@@ -28469,12 +28469,12 @@ static WORD_SUPER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUPERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERV_CHILDREN),
+static WORD_SUPERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iors"),
         dictgen::InsensitiveStr::Ascii("iosr"),
@@ -28508,12 +28508,12 @@ pub static WORD_SUPERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_SUPERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERS_CHILDREN),
+static WORD_SUPERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eed"),
@@ -28557,12 +28557,12 @@ pub static WORD_SUPERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_SUPERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERP_CHILDREN),
+static WORD_SUPERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oser"),
         dictgen::InsensitiveStr::Ascii("owereds"),
@@ -28571,12 +28571,12 @@ pub static WORD_SUPERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_SUPERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERO_CHILDREN),
+static WORD_SUPERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("peator"),
         dictgen::InsensitiveStr::Ascii("uman"),
@@ -28585,12 +28585,12 @@ pub static WORD_SUPERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_SUPERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERN_CHILDREN),
+static WORD_SUPERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arkets"),
         dictgen::InsensitiveStr::Ascii("atrual"),
@@ -28600,12 +28600,12 @@ pub static WORD_SUPERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_SUPERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERM_CHILDREN),
+static WORD_SUPERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acist"),
         dictgen::InsensitiveStr::Ascii("akert"),
@@ -28647,12 +28647,12 @@ pub static WORD_SUPERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_SUPERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERI_CHILDREN),
+static WORD_SUPERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fical"),
         dictgen::InsensitiveStr::Ascii("ntendant"),
@@ -28680,12 +28680,12 @@ pub static WORD_SUPERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_SUPERH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERH_CHILDREN),
+static WORD_SUPERH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("eo"),
@@ -28695,12 +28695,12 @@ pub static WORD_SUPERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_SUPERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERF_CHILDREN),
+static WORD_SUPERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("iciel"),
@@ -28726,12 +28726,12 @@ pub static WORD_SUPERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_SUPERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERC_CHILDREN),
+static WORD_SUPERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alifragilisticexpialidoceous"),
         dictgen::InsensitiveStr::Ascii("ede"),
@@ -28757,12 +28757,12 @@ pub static WORD_SUPERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=28,
 };
 
-static WORD_SUPERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPERB_CHILDREN),
+static WORD_SUPERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ock"),
         dictgen::InsensitiveStr::Ascii("ocks"),
@@ -28771,56 +28771,56 @@ pub static WORD_SUPERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_SUPEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPEE_CHILDREN),
+static WORD_SUPEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("na")],
     values: &[&["subpoena"]],
     range: 2..=2,
 };
 
-static WORD_SUPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPEC_CHILDREN),
+static WORD_SUPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["suspected"]],
     range: 3..=3,
 };
 
-static WORD_SUPEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUPEB_CHILDREN),
+static WORD_SUPEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUPEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUPEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUPEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lock")],
     values: &[&["superblock"]],
     range: 4..=4,
 };
 
-static WORD_SUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUO_CHILDREN),
+static WORD_SUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("p")],
     values: &[&["soup"]],
     range: 1..=1,
 };
 
-static WORD_SUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUN_CHILDREN),
+static WORD_SUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("binterpreter"),
         dictgen::InsensitiveStr::Ascii("conscious"),
@@ -28866,12 +28866,12 @@ pub static WORD_SUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_SUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUM_CHILDREN),
+static WORD_SUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amrize"),
         dictgen::InsensitiveStr::Ascii("amry"),
@@ -28973,23 +28973,23 @@ pub static WORD_SUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_SUJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUJ_CHILDREN),
+static WORD_SUJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ect")],
     values: &[&["subject"]],
     range: 3..=3,
 };
 
-static WORD_SUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUI_CHILDREN),
+static WORD_SUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ete"),
         dictgen::InsensitiveStr::Ascii("tablity"),
@@ -28999,23 +28999,23 @@ pub static WORD_SUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_SUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUH_CHILDREN),
+static WORD_SUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUH_CHILDREN),
     value: Some(&["such"]),
 };
 
-pub static WORD_SUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUG_CHILDREN),
+static WORD_SUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ery"),
@@ -29113,12 +29113,12 @@ pub static WORD_SUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_SUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUF_CHILDREN),
+static WORD_SUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -29216,12 +29216,12 @@ pub static WORD_SUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUE_CHILDREN),
+static WORD_SUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ful"),
         dictgen::InsensitiveStr::Ascii("full"),
@@ -29231,12 +29231,12 @@ pub static WORD_SUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_SUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUD_CHILDREN),
+static WORD_SUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dently"),
         dictgen::InsensitiveStr::Ascii("deny"),
@@ -29268,12 +29268,12 @@ pub static WORD_SUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUC_CHILDREN),
+static WORD_SUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUC_CHILDREN),
     value: None,
 };
 
-static WORD_SUC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_SUCC_NODE),
@@ -29302,12 +29302,12 @@ static WORD_SUC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCS_CHILDREN),
+static WORD_SUCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ede"),
         dictgen::InsensitiveStr::Ascii("eptible"),
@@ -29323,23 +29323,23 @@ pub static WORD_SUCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCO_CHILDREN),
+static WORD_SUCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("me")],
     values: &[&["succumb"]],
     range: 2..=2,
 };
 
-static WORD_SUCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCI_CHILDREN),
+static WORD_SUCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("dial"),
@@ -29348,12 +29348,12 @@ pub static WORD_SUCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SUCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCE_CHILDREN),
+static WORD_SUCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eded"),
@@ -29447,12 +29447,12 @@ pub static WORD_SUCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SUCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUCC_CHILDREN),
+static WORD_SUCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUCC_CHILDREN),
     value: None,
 };
 
-static WORD_SUCC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUCC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_SUCCC_NODE),
@@ -29481,23 +29481,23 @@ static WORD_SUCC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUCCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCU_CHILDREN),
+static WORD_SUCCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ssfully")],
     values: &[&["successfully"]],
     range: 7..=7,
 };
 
-static WORD_SUCCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCS_CHILDREN),
+static WORD_SUCCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eeded"),
         dictgen::InsensitiveStr::Ascii("esfull"),
@@ -29519,12 +29519,12 @@ pub static WORD_SUCCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SUCCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCI_CHILDREN),
+static WORD_SUCCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cently"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -29540,12 +29540,12 @@ pub static WORD_SUCCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SUCCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCE_CHILDREN),
+static WORD_SUCCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cful"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -29669,12 +29669,12 @@ pub static WORD_SUCCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SUCCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUCCC_CHILDREN),
+static WORD_SUCCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUCCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUCCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUCCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eed"),
         dictgen::InsensitiveStr::Ascii("eeded"),
@@ -29704,12 +29704,12 @@ pub static WORD_SUCCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUB_CHILDREN),
+static WORD_SUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUB_CHILDREN),
     value: None,
 };
 
-static WORD_SUB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SUBA_NODE),
     Some(&WORD_SUBB_NODE),
     Some(&WORD_SUBC_NODE),
@@ -29738,12 +29738,12 @@ static WORD_SUB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUBY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBY_CHILDREN),
+static WORD_SUBY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stem"),
         dictgen::InsensitiveStr::Ascii("stems"),
@@ -29752,23 +29752,23 @@ pub static WORD_SUBY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_SUBU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBU_CHILDREN),
+static WORD_SUBU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rburban")],
     values: &[&["suburban"]],
     range: 7..=7,
 };
 
-static WORD_SUBT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBT_CHILDREN),
+static WORD_SUBT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abels"),
         dictgen::InsensitiveStr::Ascii("ak"),
@@ -29866,12 +29866,12 @@ pub static WORD_SUBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SUBS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUBS_CHILDREN),
+static WORD_SUBS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUBS_CHILDREN),
     value: None,
 };
 
-static WORD_SUBS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUBS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SUBSA_NODE),
     None,
     Some(&WORD_SUBSC_NODE),
@@ -29900,12 +29900,12 @@ static WORD_SUBS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUBSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSY_CHILDREN),
+static WORD_SUBSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sthem"),
         dictgen::InsensitiveStr::Ascii("sthems"),
@@ -29929,23 +29929,23 @@ pub static WORD_SUBSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SUBSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSU_CHILDREN),
+static WORD_SUBSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dized")],
     values: &[&["subsidized"]],
     range: 5..=5,
 };
 
-static WORD_SUBST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SUBST_CHILDREN),
+static WORD_SUBST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SUBST_CHILDREN),
     value: None,
 };
 
-static WORD_SUBST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SUBST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SUBSTA_NODE),
     None,
     None,
@@ -29974,12 +29974,12 @@ static WORD_SUBST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SUBSTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTU_CHILDREN),
+static WORD_SUBSTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cture"),
         dictgen::InsensitiveStr::Ascii("ctures"),
@@ -29993,12 +29993,12 @@ pub static WORD_SUBSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_SUBSTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTR_CHILDREN),
+static WORD_SUBSTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -30020,12 +30020,12 @@ pub static WORD_SUBSTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_SUBSTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTI_CHILDREN),
+static WORD_SUBSTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bute"),
         dictgen::InsensitiveStr::Ascii("stutions"),
@@ -30109,12 +30109,12 @@ pub static WORD_SUBSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_SUBSTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTE_CHILDREN),
+static WORD_SUBSTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nces"),
         dictgen::InsensitiveStr::Ascii("ntial"),
@@ -30124,12 +30124,12 @@ pub static WORD_SUBSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_SUBSTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTA_CHILDREN),
+static WORD_SUBSTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -30195,12 +30195,12 @@ pub static WORD_SUBSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_SUBSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSR_CHILDREN),
+static WORD_SUBSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cibe"),
         dictgen::InsensitiveStr::Ascii("cibed"),
@@ -30222,12 +30222,12 @@ pub static WORD_SUBSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SUBSQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSQ_CHILDREN),
+static WORD_SUBSQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uent"),
         dictgen::InsensitiveStr::Ascii("uently"),
@@ -30236,12 +30236,12 @@ pub static WORD_SUBSQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_SUBSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSI_CHILDREN),
+static WORD_SUBSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dary"),
         dictgen::InsensitiveStr::Ascii("dezed"),
@@ -30317,12 +30317,12 @@ pub static WORD_SUBSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SUBSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSH_CHILDREN),
+static WORD_SUBSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ystem"),
         dictgen::InsensitiveStr::Ascii("ystems"),
@@ -30331,12 +30331,12 @@ pub static WORD_SUBSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_SUBSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSE_CHILDREN),
+static WORD_SUBSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crion"),
         dictgen::InsensitiveStr::Ascii("dent"),
@@ -30378,12 +30378,12 @@ pub static WORD_SUBSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_SUBSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSC_CHILDREN),
+static WORD_SUBSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eptible"),
         dictgen::InsensitiveStr::Ascii("ibe"),
@@ -30483,23 +30483,23 @@ pub static WORD_SUBSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SUBSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBSA_CHILDREN),
+static WORD_SUBSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dized")],
     values: &[&["subsidized"]],
     range: 5..=5,
 };
 
-static WORD_SUBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBR_CHILDREN),
+static WORD_SUBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -30533,23 +30533,23 @@ pub static WORD_SUBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_SUBQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBQ_CHILDREN),
+static WORD_SUBQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uue")],
     values: &[&["subqueue"]],
     range: 3..=3,
 };
 
-static WORD_SUBP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBP_CHILDREN),
+static WORD_SUBP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ackge"),
         dictgen::InsensitiveStr::Ascii("ackges"),
@@ -30571,12 +30571,12 @@ pub static WORD_SUBP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SUBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBO_CHILDREN),
+static WORD_SUBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bjecs"),
         dictgen::InsensitiveStr::Ascii("lders"),
@@ -30594,12 +30594,12 @@ pub static WORD_SUBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_SUBN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBN_CHILDREN),
+static WORD_SUBN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egatiotiation"),
         dictgen::InsensitiveStr::Ascii("egatiotiations"),
@@ -30699,12 +30699,12 @@ pub static WORD_SUBN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=18,
 };
 
-static WORD_SUBM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBM_CHILDREN),
+static WORD_SUBM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achne"),
         dictgen::InsensitiveStr::Ascii("arie"),
@@ -30762,12 +30762,12 @@ pub static WORD_SUBM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SUBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBL_CHILDREN),
+static WORD_SUBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ass"),
         dictgen::InsensitiveStr::Ascii("asse"),
@@ -30793,12 +30793,12 @@ pub static WORD_SUBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SUBJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBJ_CHILDREN),
+static WORD_SUBJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ec"),
         dictgen::InsensitiveStr::Ascii("ectief"),
@@ -30832,12 +30832,12 @@ pub static WORD_SUBJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SUBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBI_CHILDREN),
+static WORD_SUBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rectory"),
         dictgen::InsensitiveStr::Ascii("sdized"),
@@ -30853,23 +30853,23 @@ pub static WORD_SUBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SUBG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBG_CHILDREN),
+static WORD_SUBG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("region")],
     values: &[&["subregion"]],
     range: 6..=6,
 };
 
-static WORD_SUBF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBF_CHILDREN),
+static WORD_SUBF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eatutures"),
         dictgen::InsensitiveStr::Ascii("olfer"),
@@ -30891,12 +30891,12 @@ pub static WORD_SUBF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_SUBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBE_CHILDREN),
+static WORD_SUBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lemet"),
         dictgen::InsensitiveStr::Ascii("lemets"),
@@ -30936,12 +30936,12 @@ pub static WORD_SUBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_SUBD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBD_CHILDREN),
+static WORD_SUBD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irectiories"),
         dictgen::InsensitiveStr::Ascii("irectoires"),
@@ -30969,12 +30969,12 @@ pub static WORD_SUBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_SUBC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBC_CHILDREN),
+static WORD_SUBC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atagories"),
         dictgen::InsensitiveStr::Ascii("atagory"),
@@ -31038,12 +31038,12 @@ pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_SUBB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBB_CHILDREN),
+static WORD_SUBB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mitted"),
         dictgen::InsensitiveStr::Ascii("tle"),
@@ -31052,12 +31052,12 @@ pub static WORD_SUBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SUBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUBA_CHILDREN),
+static WORD_SUBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rmine"),
         dictgen::InsensitiveStr::Ascii("rmines"),
@@ -31066,12 +31066,12 @@ pub static WORD_SUBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_SUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SUA_CHILDREN),
+static WORD_SUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sage"),
         dictgen::InsensitiveStr::Ascii("sages"),
@@ -31080,12 +31080,12 @@ pub static WORD_SUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_ST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ST_CHILDREN),
+static WORD_ST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ST_CHILDREN),
     value: None,
 };
 
-static WORD_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STA_NODE),
     None,
     Some(&WORD_STC_NODE),
@@ -31114,12 +31114,12 @@ static WORD_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STY_CHILDREN),
+static WORD_STY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STY_CHILDREN),
     value: None,
 };
 
-pub static WORD_STY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("ilistic"),
@@ -31147,12 +31147,12 @@ pub static WORD_STY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_STU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STU_CHILDREN),
+static WORD_STU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STU_CHILDREN),
     value: None,
 };
 
-static WORD_STU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STUA_NODE),
     Some(&WORD_STUB_NODE),
     Some(&WORD_STUC_NODE),
@@ -31181,12 +31181,12 @@ static WORD_STU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUT_CHILDREN),
+static WORD_STUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("down"),
         dictgen::InsensitiveStr::Ascii("terring"),
@@ -31196,12 +31196,12 @@ pub static WORD_STUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_STUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUR_CHILDREN),
+static WORD_STUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctural"),
@@ -31231,12 +31231,12 @@ pub static WORD_STUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_STUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUP_CHILDREN),
+static WORD_STUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dily"),
         dictgen::InsensitiveStr::Ascii("idfree"),
@@ -31260,23 +31260,23 @@ pub static WORD_STUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_STUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUN_CHILDREN),
+static WORD_STUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ami")],
     values: &[&["tsunami"]],
     range: 3..=3,
 };
 
-static WORD_STUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUM_CHILDREN),
+static WORD_STUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("beld"),
         dictgen::InsensitiveStr::Ascii("mac"),
@@ -31285,12 +31285,12 @@ pub static WORD_STUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_STUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUI_CHILDREN),
+static WORD_STUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("do"),
         dictgen::InsensitiveStr::Ascii("dos"),
@@ -31301,12 +31301,12 @@ pub static WORD_STUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_STUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUG_CHILDREN),
+static WORD_STUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gle"),
         dictgen::InsensitiveStr::Ascii("gles"),
@@ -31316,34 +31316,34 @@ pub static WORD_STUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_STUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUF_CHILDREN),
+static WORD_STUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUF_CHILDREN),
     value: Some(&["stuff"]),
 };
 
-pub static WORD_STUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_STUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUE_CHILDREN),
+static WORD_STUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nts")],
     values: &[&["students"]],
     range: 3..=3,
 };
 
-static WORD_STUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUD_CHILDREN),
+static WORD_STUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dy"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -31379,12 +31379,12 @@ pub static WORD_STUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_STUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUC_CHILDREN),
+static WORD_STUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ked"),
         dictgen::InsensitiveStr::Ascii("kt"),
@@ -31406,12 +31406,12 @@ pub static WORD_STUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_STUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUB_CHILDREN),
+static WORD_STUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bon"),
         dictgen::InsensitiveStr::Ascii("borness"),
@@ -31431,12 +31431,12 @@ pub static WORD_STUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_STUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STUA_CHILDREN),
+static WORD_STUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_STUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -31450,12 +31450,12 @@ pub static WORD_STUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_STT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STT_CHILDREN),
+static WORD_STT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STT_CHILDREN),
     value: None,
 };
 
-pub static WORD_STT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eting"),
@@ -31479,12 +31479,12 @@ pub static WORD_STT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_STS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STS_CHILDREN),
+static WORD_STS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STS_CHILDREN),
     value: None,
 };
 
-pub static WORD_STS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tionary"),
@@ -31504,12 +31504,12 @@ pub static WORD_STS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_STR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STR_CHILDREN),
+static WORD_STR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STR_CHILDREN),
     value: None,
 };
 
-static WORD_STR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STRA_NODE),
     None,
     Some(&WORD_STRC_NODE),
@@ -31538,34 +31538,34 @@ static WORD_STR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRY_CHILDREN),
+static WORD_STRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ofoam")],
     values: &[&["styrofoam"]],
     range: 5..=5,
 };
 
-static WORD_STRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRW_CHILDREN),
+static WORD_STRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aberry")],
     values: &[&["strawberry"]],
     range: 6..=6,
 };
 
-static WORD_STRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRU_CHILDREN),
+static WORD_STRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cgture"),
@@ -31691,34 +31691,34 @@ pub static WORD_STRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_STRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRT_CHILDREN),
+static WORD_STRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["string"]],
     range: 3..=3,
 };
 
-static WORD_STRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRP_CHILDREN),
+static WORD_STRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iped")],
     values: &[&["stripped"]],
     range: 4..=4,
 };
 
-static WORD_STRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRO_CHILDREN),
+static WORD_STRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -31766,12 +31766,12 @@ pub static WORD_STRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_STRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRN_CHILDREN),
+static WORD_STRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -31780,23 +31780,23 @@ pub static WORD_STRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_STRK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRK_CHILDREN),
+static WORD_STRK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRK_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ethrough")],
     values: &[&["strikethrough"]],
     range: 8..=8,
 };
 
-static WORD_STRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRI_CHILDREN),
+static WORD_STRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aght"),
         dictgen::InsensitiveStr::Ascii("aghten"),
@@ -31878,12 +31878,12 @@ pub static WORD_STRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_STRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STRE_CHILDREN),
+static WORD_STRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STRE_CHILDREN),
     value: None,
 };
 
-static WORD_STRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STREA_NODE),
     None,
     Some(&WORD_STREC_NODE),
@@ -31912,12 +31912,12 @@ static WORD_STRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRET_CHILDREN),
+static WORD_STRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRET_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chs"),
         dictgen::InsensitiveStr::Ascii("egically"),
@@ -31926,12 +31926,12 @@ pub static WORD_STRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_STRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRES_CHILDREN),
+static WORD_STRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sade"),
         dictgen::InsensitiveStr::Ascii("sende"),
@@ -31949,34 +31949,34 @@ pub static WORD_STRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_STRER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRER_CHILDREN),
+static WORD_STRER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRER_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rror")],
     values: &[&["strerror"]],
     range: 4..=4,
 };
 
-static WORD_STREO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREO_CHILDREN),
+static WORD_STREO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREO_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("id")],
     values: &[&["steroid"]],
     range: 2..=2,
 };
 
-static WORD_STREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREN_CHILDREN),
+static WORD_STREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gh"),
         dictgen::InsensitiveStr::Ascii("ghen"),
@@ -32030,12 +32030,12 @@ pub static WORD_STREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_STREM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREM_CHILDREN),
+static WORD_STREM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREM_CHILDREN),
     value: Some(&["stream"]),
 };
 
-pub static WORD_STREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ear"),
@@ -32044,12 +32044,12 @@ pub static WORD_STREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_STREI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREI_CHILDREN),
+static WORD_STREI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chung"),
         dictgen::InsensitiveStr::Ascii("ght"),
@@ -32081,12 +32081,12 @@ pub static WORD_STREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_STREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREG_CHILDREN),
+static WORD_STREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nth"),
         dictgen::InsensitiveStr::Ascii("nthen"),
@@ -32104,12 +32104,12 @@ pub static WORD_STREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_STREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREE_CHILDREN),
+static WORD_STREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mlining"),
@@ -32118,12 +32118,12 @@ pub static WORD_STREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_STREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREC_CHILDREN),
+static WORD_STREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hed"),
@@ -32155,12 +32155,12 @@ pub static WORD_STREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_STREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STREA_CHILDREN),
+static WORD_STREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_STREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ching"),
         dictgen::InsensitiveStr::Ascii("made"),
@@ -32202,12 +32202,12 @@ pub static WORD_STREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_STRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRC_CHILDREN),
+static WORD_STRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iter"),
         dictgen::InsensitiveStr::Ascii("ture"),
@@ -32229,12 +32229,12 @@ pub static WORD_STRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_STRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STRA_CHILDREN),
+static WORD_STRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STRA_CHILDREN),
     value: None,
 };
 
-static WORD_STRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_STRAC_NODE),
@@ -32263,12 +32263,12 @@ static WORD_STRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STRAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAW_CHILDREN),
+static WORD_STRAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("barry"),
         dictgen::InsensitiveStr::Ascii("beary"),
@@ -32298,23 +32298,23 @@ pub static WORD_STRAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_STRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAV_CHILDREN),
+static WORD_STRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["starvation"]],
     range: 5..=5,
 };
 
-static WORD_STRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAT_CHILDREN),
+static WORD_STRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAT_CHILDREN),
     value: Some(&["start", "strata"]),
 };
 
-pub static WORD_STRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agically"),
         dictgen::InsensitiveStr::Ascii("agies"),
@@ -32362,12 +32362,12 @@ pub static WORD_STRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_STRAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAR_CHILDREN),
+static WORD_STRAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -32378,12 +32378,12 @@ pub static WORD_STRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_STRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAN_CHILDREN),
+static WORD_STRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAN_CHILDREN),
     value: Some(&["strand", "strain"]),
 };
 
-pub static WORD_STRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gel"),
@@ -32409,12 +32409,12 @@ pub static WORD_STRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_STRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAM_CHILDREN),
+static WORD_STRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAM_CHILDREN),
     value: Some(&["steam", "stream", "tram"]),
 };
 
-pub static WORD_STRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -32423,12 +32423,12 @@ pub static WORD_STRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_STRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAI_CHILDREN),
+static WORD_STRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gh"),
         dictgen::InsensitiveStr::Ascii("ghforward"),
@@ -32492,12 +32492,12 @@ pub static WORD_STRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_STRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAG_CHILDREN),
+static WORD_STRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("edy"),
@@ -32523,12 +32523,12 @@ pub static WORD_STRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_STRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAD_CHILDREN),
+static WORD_STRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egies"),
         dictgen::InsensitiveStr::Ascii("egy"),
@@ -32537,23 +32537,23 @@ pub static WORD_STRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_STRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STRAC_CHILDREN),
+static WORD_STRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["stack", "track"]],
     range: 1..=1,
 };
 
-static WORD_STP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STP_CHILDREN),
+static WORD_STP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STP_CHILDREN),
     value: None,
 };
 
-pub static WORD_STP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iped"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -32562,12 +32562,12 @@ pub static WORD_STP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_STO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STO_CHILDREN),
+static WORD_STO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STO_CHILDREN),
     value: None,
 };
 
-pub static WORD_STO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -32675,12 +32675,12 @@ pub static WORD_STO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_STN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STN_CHILDREN),
+static WORD_STN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("dard"),
@@ -32689,12 +32689,12 @@ pub static WORD_STN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_STL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STL_CHILDREN),
+static WORD_STL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STL_CHILDREN),
     value: None,
 };
 
-pub static WORD_STL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aker"),
         dictgen::InsensitiveStr::Ascii("akers"),
@@ -32716,12 +32716,12 @@ pub static WORD_STL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_STI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STI_CHILDREN),
+static WORD_STI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ches"),
         dictgen::InsensitiveStr::Ascii("chted"),
@@ -32819,23 +32819,23 @@ pub static WORD_STI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_STH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STH_CHILDREN),
+static WORD_STH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STH_CHILDREN),
     value: None,
 };
 
-pub static WORD_STH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["the"]],
     range: 1..=1,
 };
 
-static WORD_STE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STE_CHILDREN),
+static WORD_STE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STE_CHILDREN),
     value: None,
 };
 
-pub static WORD_STE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adilly"),
         dictgen::InsensitiveStr::Ascii("adliy"),
@@ -32961,12 +32961,12 @@ pub static WORD_STE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_STD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STD_CHILDREN),
+static WORD_STD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STD_CHILDREN),
     value: None,
 };
 
-pub static WORD_STD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anard"),
         dictgen::InsensitiveStr::Ascii("anards"),
@@ -32986,23 +32986,23 @@ pub static WORD_STD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_STC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STC_CHILDREN),
+static WORD_STC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("okbrush")],
     values: &[&["stockbrush"]],
     range: 7..=7,
 };
 
-static WORD_STA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STA_CHILDREN),
+static WORD_STA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STA_CHILDREN),
     value: None,
 };
 
-static WORD_STA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STAA_NODE),
     Some(&WORD_STAB_NODE),
     Some(&WORD_STAC_NODE),
@@ -33031,12 +33031,12 @@ static WORD_STA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAW_CHILDREN),
+static WORD_STAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("berries"),
         dictgen::InsensitiveStr::Ascii("berry"),
@@ -33046,12 +33046,12 @@ pub static WORD_STAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_STAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAU_CHILDREN),
+static WORD_STAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lk"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -33073,12 +33073,12 @@ pub static WORD_STAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_STAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_STAT_CHILDREN),
+static WORD_STAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_STAT_CHILDREN),
     value: None,
 };
 
-static WORD_STAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_STAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_STATA_NODE),
     None,
     None,
@@ -33107,12 +33107,12 @@ static WORD_STAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_STATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATU_CHILDREN),
+static WORD_STATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATU_CHILDREN),
     value: Some(&["status"]),
 };
 
-pub static WORD_STATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bar"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -33148,12 +33148,12 @@ pub static WORD_STATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_STATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATT_CHILDREN),
+static WORD_STATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ered"),
         dictgen::InsensitiveStr::Ascii("istic"),
@@ -33164,12 +33164,12 @@ pub static WORD_STATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_STATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATS_CHILDREN),
+static WORD_STATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("itical"),
@@ -33178,12 +33178,12 @@ pub static WORD_STATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_STATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATR_CHILDREN),
+static WORD_STATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -33192,12 +33192,12 @@ pub static WORD_STATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_STATM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATM_CHILDREN),
+static WORD_STATM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATM_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enet"),
         dictgen::InsensitiveStr::Ascii("enmt"),
@@ -33213,23 +33213,23 @@ pub static WORD_STATM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_STATL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATL_CHILDREN),
+static WORD_STATL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATL_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["stateless"]],
     range: 3..=3,
 };
 
-static WORD_STATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATI_CHILDREN),
+static WORD_STATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATI_CHILDREN),
     value: Some(&["statuses", "state", "static"]),
 };
 
-pub static WORD_STATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caly"),
         dictgen::InsensitiveStr::Ascii("cists"),
@@ -33309,12 +33309,12 @@ pub static WORD_STATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_STATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATE_CHILDREN),
+static WORD_STATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("full"),
         dictgen::InsensitiveStr::Ascii("gies"),
@@ -33362,12 +33362,12 @@ pub static WORD_STATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_STATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STATA_CHILDREN),
+static WORD_STATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_STATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("menet"),
         dictgen::InsensitiveStr::Ascii("menets"),
@@ -33376,12 +33376,12 @@ pub static WORD_STATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_STAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAR_CHILDREN),
+static WORD_STAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -33475,34 +33475,34 @@ pub static WORD_STAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_STAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAP_CHILDREN),
+static WORD_STAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAP_CHILDREN),
     value: Some(&["step", "stop"]),
 };
 
-pub static WORD_STAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["steps", "stops"]],
     range: 1..=1,
 };
 
-static WORD_STAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAO_CHILDREN),
+static WORD_STAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("shi")],
     values: &[&["satoshi"]],
     range: 3..=3,
 };
 
-static WORD_STAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAN_CHILDREN),
+static WORD_STAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alone"),
         dictgen::InsensitiveStr::Ascii("ard"),
@@ -33608,12 +33608,12 @@ pub static WORD_STAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_STAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAM_CHILDREN),
+static WORD_STAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("entent"),
@@ -33633,12 +33633,12 @@ pub static WORD_STAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_STAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAL_CHILDREN),
+static WORD_STAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agtite"),
         dictgen::InsensitiveStr::Ascii("ekrs"),
@@ -33649,12 +33649,12 @@ pub static WORD_STAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_STAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAK_CHILDREN),
+static WORD_STAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eboard"),
         dictgen::InsensitiveStr::Ascii("eboarding"),
@@ -33670,12 +33670,12 @@ pub static WORD_STAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_STAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAI_CHILDREN),
+static WORD_STAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cally"),
         dictgen::InsensitiveStr::Ascii("dum"),
@@ -33703,12 +33703,12 @@ pub static WORD_STAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_STAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAG_CHILDREN),
+static WORD_STAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("garing"),
         dictgen::InsensitiveStr::Ascii("gerring"),
@@ -33724,34 +33724,34 @@ pub static WORD_STAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_STAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAF_CHILDREN),
+static WORD_STAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAF_CHILDREN),
     value: Some(&["staff"]),
 };
 
-pub static WORD_STAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_STAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAE_CHILDREN),
+static WORD_STAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAE_CHILDREN),
     value: Some(&["state"]),
 };
 
-pub static WORD_STAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ment")],
     values: &[&["statement"]],
     range: 4..=4,
 };
 
-static WORD_STAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAD_CHILDREN),
+static WORD_STAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ius"),
@@ -33785,12 +33785,12 @@ pub static WORD_STAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_STAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAC_CHILDREN),
+static WORD_STAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("ionary"),
@@ -33800,12 +33800,12 @@ pub static WORD_STAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_STAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAB_CHILDREN),
+static WORD_STAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alization"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -33861,23 +33861,23 @@ pub static WORD_STAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_STAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_STAA_CHILDREN),
+static WORD_STAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_STAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_STAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_STAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tus")],
     values: &[&["status"]],
     range: 3..=3,
 };
 
-static WORD_SS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SS_CHILDREN),
+static WORD_SS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ame"),
         dictgen::InsensitiveStr::Ascii("ee"),
@@ -33899,12 +33899,12 @@ pub static WORD_SS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SR_CHILDREN),
+static WORD_SR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arted"),
         dictgen::InsensitiveStr::Ascii("bg"),
@@ -33996,12 +33996,12 @@ pub static WORD_SR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_SQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SQ_CHILDREN),
+static WORD_SQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("ared"),
@@ -34107,12 +34107,12 @@ pub static WORD_SQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SP_CHILDREN),
+static WORD_SP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SP_CHILDREN),
     value: None,
 };
 
-static WORD_SP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPA_NODE),
     None,
     Some(&WORD_SPC_NODE),
@@ -34141,12 +34141,12 @@ static WORD_SP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPW_CHILDREN),
+static WORD_SPW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("aned"),
@@ -34157,12 +34157,12 @@ pub static WORD_SPW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPU_CHILDREN),
+static WORD_SPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rios"),
         dictgen::InsensitiveStr::Ascii("rrious"),
@@ -34171,23 +34171,23 @@ pub static WORD_SPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_SPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPT_CHILDREN),
+static WORD_SPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("intf")],
     values: &[&["sprintf"]],
     range: 4..=4,
 };
 
-static WORD_SPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPS_CHILDREN),
+static WORD_SPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -34198,12 +34198,12 @@ pub static WORD_SPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_SPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPR_CHILDREN),
+static WORD_SPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("akling"),
         dictgen::InsensitiveStr::Ascii("ayade"),
@@ -34307,12 +34307,12 @@ pub static WORD_SPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_SPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPP_CHILDREN),
+static WORD_SPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eches"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -34332,12 +34332,12 @@ pub static WORD_SPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPO_CHILDREN),
+static WORD_SPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -34467,12 +34467,12 @@ pub static WORD_SPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_SPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPL_CHILDREN),
+static WORD_SPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aton"),
         dictgen::InsensitiveStr::Ascii("atooon"),
@@ -34514,12 +34514,12 @@ pub static WORD_SPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPI_CHILDREN),
+static WORD_SPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cific"),
         dictgen::InsensitiveStr::Ascii("cified"),
@@ -34583,12 +34583,12 @@ pub static WORD_SPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_SPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPH_CHILDREN),
+static WORD_SPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agetti"),
         dictgen::InsensitiveStr::Ascii("ereos"),
@@ -34597,12 +34597,12 @@ pub static WORD_SPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_SPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPE_CHILDREN),
+static WORD_SPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPE_CHILDREN),
     value: None,
 };
 
-static WORD_SPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEA_NODE),
     None,
     Some(&WORD_SPEC_NODE),
@@ -34631,12 +34631,12 @@ static WORD_SPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEZ_NODE),
 ];
 
-static WORD_SPEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEZ_CHILDREN),
+static WORD_SPEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialiced"),
         dictgen::InsensitiveStr::Ascii("ialisation"),
@@ -34654,12 +34654,12 @@ pub static WORD_SPEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPET_CHILDREN),
+static WORD_SPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ember"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -34675,12 +34675,12 @@ pub static WORD_SPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPES_CHILDREN),
+static WORD_SPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hal"),
         dictgen::InsensitiveStr::Ascii("hally"),
@@ -34718,12 +34718,12 @@ pub static WORD_SPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPER_CHILDREN),
+static WORD_SPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ately"),
@@ -34739,12 +34739,12 @@ pub static WORD_SPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SPEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEP_CHILDREN),
+static WORD_SPEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("arated"),
@@ -34780,23 +34780,23 @@ pub static WORD_SPEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEN_CHILDREN),
+static WORD_SPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dour")],
     values: &[&["splendour"]],
     range: 4..=4,
 };
 
-static WORD_SPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEL_CHILDREN),
+static WORD_SPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("lig"),
@@ -34812,23 +34812,23 @@ pub static WORD_SPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SPEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEK_CHILDREN),
+static WORD_SPEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aing")],
     values: &[&["speaking"]],
     range: 4..=4,
 };
 
-static WORD_SPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEI_CHILDREN),
+static WORD_SPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("calist"),
@@ -34860,12 +34860,12 @@ pub static WORD_SPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SPEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEH_CHILDREN),
+static WORD_SPEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erical"),
         dictgen::InsensitiveStr::Ascii("res"),
@@ -34875,12 +34875,12 @@ pub static WORD_SPEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SPEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEF_CHILDREN),
+static WORD_SPEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEF_CHILDREN),
     value: None,
 };
 
-static WORD_SPEF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEFA_NODE),
     None,
     Some(&WORD_SPEFC_NODE),
@@ -34909,23 +34909,23 @@ static WORD_SPEF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPEFY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFY_CHILDREN),
+static WORD_SPEFY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPEFY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["specifying"]],
     range: 3..=3,
 };
 
-static WORD_SPEFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEFI_CHILDREN),
+static WORD_SPEFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEFI_CHILDREN),
     value: None,
 };
 
-static WORD_SPEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEFI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEFIA_NODE),
     None,
     Some(&WORD_SPEFIC_NODE),
@@ -34954,23 +34954,23 @@ static WORD_SPEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPEFIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIY_CHILDREN),
+static WORD_SPEFIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPEFIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["specifying"]],
     range: 3..=3,
 };
 
-static WORD_SPEFIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIX_CHILDREN),
+static WORD_SPEFIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35024,12 +35024,12 @@ pub static WORD_SPEFIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_SPEFII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFII_CHILDREN),
+static WORD_SPEFII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFII_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -35103,12 +35103,12 @@ pub static WORD_SPEFII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_SPEFIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIF_CHILDREN),
+static WORD_SPEFIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35170,12 +35170,12 @@ pub static WORD_SPEFIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_SPEFIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIE_CHILDREN),
+static WORD_SPEFIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -35191,12 +35191,12 @@ pub static WORD_SPEFIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_SPEFIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEFIC_CHILDREN),
+static WORD_SPEFIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEFIC_CHILDREN),
     value: Some(&["specific"]),
 };
 
-static WORD_SPEFIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEFIC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEFICA_NODE),
     None,
     None,
@@ -35225,34 +35225,34 @@ static WORD_SPEFIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPEFICY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICY_CHILDREN),
+static WORD_SPEFICY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPEFICY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["specifying"]],
     range: 3..=3,
 };
 
-static WORD_SPEFICS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICS_CHILDREN),
+static WORD_SPEFICS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICS_CHILDREN),
     value: Some(&["specifics"]),
 };
 
-pub static WORD_SPEFICS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SPEFICI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEFICI_CHILDREN),
+static WORD_SPEFICI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEFICI_CHILDREN),
     value: None,
 };
 
-static WORD_SPEFICI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEFICI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPEFICIA_NODE),
     None,
     Some(&WORD_SPEFICIC_NODE),
@@ -35281,23 +35281,23 @@ static WORD_SPEFICI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPEFICIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIY_CHILDREN),
+static WORD_SPEFICIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPEFICIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["specifying"]],
     range: 3..=3,
 };
 
-static WORD_SPEFICIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIT_CHILDREN),
+static WORD_SPEFICIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35349,12 +35349,12 @@ pub static WORD_SPEFICIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_SPEFICIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIL_CHILDREN),
+static WORD_SPEFICIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lally"),
         dictgen::InsensitiveStr::Ascii("lation"),
@@ -35406,12 +35406,12 @@ pub static WORD_SPEFICIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=9,
 };
 
-static WORD_SPEFICII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICII_CHILDREN),
+static WORD_SPEFICII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICII_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -35447,12 +35447,12 @@ pub static WORD_SPEFICII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=7,
 };
 
-static WORD_SPEFICIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIF_CHILDREN),
+static WORD_SPEFICIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35524,12 +35524,12 @@ pub static WORD_SPEFICIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_SPEFICIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIE_CHILDREN),
+static WORD_SPEFICIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -35553,12 +35553,12 @@ pub static WORD_SPEFICIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=3,
 };
 
-static WORD_SPEFICIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIC_CHILDREN),
+static WORD_SPEFICIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIC_CHILDREN),
     value: Some(&["specific"]),
 };
 
-pub static WORD_SPEFICIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -35574,12 +35574,12 @@ pub static WORD_SPEFICIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=6,
 };
 
-static WORD_SPEFICIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIA_CHILDREN),
+static WORD_SPEFICIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("llally"),
@@ -35637,12 +35637,12 @@ pub static WORD_SPEFICIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 3..=10,
 };
 
-static WORD_SPEFICE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICE_CHILDREN),
+static WORD_SPEFICE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -35666,12 +35666,12 @@ pub static WORD_SPEFICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_SPEFICA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICA_CHILDREN),
+static WORD_SPEFICA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFICA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFICA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -35687,12 +35687,12 @@ pub static WORD_SPEFICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=5,
 };
 
-static WORD_SPEFIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIA_CHILDREN),
+static WORD_SPEFIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -35701,12 +35701,12 @@ pub static WORD_SPEFIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_SPEFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFE_CHILDREN),
+static WORD_SPEFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("id"),
         dictgen::InsensitiveStr::Ascii("ir"),
@@ -35722,12 +35722,12 @@ pub static WORD_SPEFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SPEFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFC_CHILDREN),
+static WORD_SPEFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifiable"),
         dictgen::InsensitiveStr::Ascii("ific"),
@@ -35759,12 +35759,12 @@ pub static WORD_SPEFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_SPEFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEFA_CHILDREN),
+static WORD_SPEFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lly"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -35778,12 +35778,12 @@ pub static WORD_SPEFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SPEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEE_CHILDREN),
+static WORD_SPEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("aking"),
@@ -35815,12 +35815,12 @@ pub static WORD_SPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPED_CHILDREN),
+static WORD_SPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ific"),
         dictgen::InsensitiveStr::Ascii("ified"),
@@ -35830,12 +35830,12 @@ pub static WORD_SPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPEC_CHILDREN),
+static WORD_SPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPEC_CHILDREN),
     value: None,
 };
 
-static WORD_SPEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPECA_NODE),
     None,
     None,
@@ -35864,23 +35864,23 @@ static WORD_SPEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPECY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECY_CHILDREN),
+static WORD_SPECY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fing")],
     values: &[&["specifying"]],
     range: 4..=4,
 };
 
-static WORD_SPECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECU_CHILDREN),
+static WORD_SPECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alte"),
         dictgen::InsensitiveStr::Ascii("alting"),
@@ -35910,12 +35910,12 @@ pub static WORD_SPECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SPECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECT_CHILDREN),
+static WORD_SPECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acuarly"),
         dictgen::InsensitiveStr::Ascii("aculair"),
@@ -35987,34 +35987,34 @@ pub static WORD_SPECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SPECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECR_CHILDREN),
+static WORD_SPECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tal")],
     values: &[&["spectral"]],
     range: 3..=3,
 };
 
-static WORD_SPECK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECK_CHILDREN),
+static WORD_SPECK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tor")],
     values: &[&["specter"]],
     range: 3..=3,
 };
 
-static WORD_SPECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPECI_CHILDREN),
+static WORD_SPECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPECI_CHILDREN),
     value: None,
 };
 
-static WORD_SPECI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPECI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPECIA_NODE),
     None,
     Some(&WORD_SPECIC_NODE),
@@ -36043,12 +36043,12 @@ static WORD_SPECI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPECIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIY_CHILDREN),
+static WORD_SPECIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIY_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPECIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fing"),
         dictgen::InsensitiveStr::Ascii("fying"),
@@ -36058,34 +36058,34 @@ pub static WORD_SPECIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_SPECIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIV_CHILDREN),
+static WORD_SPECIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ied")],
     values: &[&["specified"]],
     range: 3..=3,
 };
 
-static WORD_SPECIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIS_CHILDREN),
+static WORD_SPECIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["specials"]],
     range: 1..=1,
 };
 
-static WORD_SPECIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIR_CHILDREN),
+static WORD_SPECIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -36094,12 +36094,12 @@ pub static WORD_SPECIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_SPECIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIM_CHILDREN),
+static WORD_SPECIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("ine"),
@@ -36109,12 +36109,12 @@ pub static WORD_SPECIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_SPECIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIL_CHILDREN),
+static WORD_SPECIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aized"),
         dictgen::InsensitiveStr::Ascii("azations"),
@@ -36142,12 +36142,12 @@ pub static WORD_SPECIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_SPECII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECII_CHILDREN),
+static WORD_SPECII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECII_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -36165,12 +36165,12 @@ pub static WORD_SPECII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_SPECIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SPECIF_CHILDREN),
+static WORD_SPECIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SPECIF_CHILDREN),
     value: None,
 };
 
-static WORD_SPECIF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SPECIF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SPECIFA_NODE),
     None,
     Some(&WORD_SPECIFC_NODE),
@@ -36199,12 +36199,12 @@ static WORD_SPECIF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SPECIFY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFY_CHILDREN),
+static WORD_SPECIFY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -36220,45 +36220,45 @@ pub static WORD_SPECIFY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_SPECIFV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFV_CHILDREN),
+static WORD_SPECIFV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFV_CHILDREN),
     value: Some(&["specific"]),
 };
 
-pub static WORD_SPECIFV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SPECIFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFU_CHILDREN),
+static WORD_SPECIFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFU_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPECIFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SPECIFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFT_CHILDREN),
+static WORD_SPECIFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFT_CHILDREN),
     value: Some(&["specify"]),
 };
 
-pub static WORD_SPECIFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SPECIFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFR_CHILDREN),
+static WORD_SPECIFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -36267,12 +36267,12 @@ pub static WORD_SPECIFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=3,
 };
 
-static WORD_SPECIFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFI_CHILDREN),
+static WORD_SPECIFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFI_CHILDREN),
     value: Some(&["specific", "specify"]),
 };
 
-pub static WORD_SPECIFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -36384,12 +36384,12 @@ pub static WORD_SPECIFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_SPECIFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFF_CHILDREN),
+static WORD_SPECIFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -36398,12 +36398,12 @@ pub static WORD_SPECIFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_SPECIFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFE_CHILDREN),
+static WORD_SPECIFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -36413,12 +36413,12 @@ pub static WORD_SPECIFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=2,
 };
 
-static WORD_SPECIFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFC_CHILDREN),
+static WORD_SPECIFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFC_CHILDREN),
     value: Some(&["specific"]),
 };
 
-pub static WORD_SPECIFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -36436,23 +36436,23 @@ pub static WORD_SPECIFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=6,
 };
 
-static WORD_SPECIFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFA_CHILDREN),
+static WORD_SPECIFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ctions")],
     values: &[&["specifications"]],
     range: 6..=6,
 };
 
-static WORD_SPECIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIE_CHILDREN),
+static WORD_SPECIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -36461,23 +36461,23 @@ pub static WORD_SPECIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_SPECID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECID_CHILDREN),
+static WORD_SPECID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECID_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ic")],
     values: &[&["specific"]],
     range: 2..=2,
 };
 
-static WORD_SPECIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIC_CHILDREN),
+static WORD_SPECIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIC_CHILDREN),
     value: Some(&["specific"]),
 };
 
-pub static WORD_SPECIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -36487,12 +36487,12 @@ pub static WORD_SPECIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_SPECIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECIA_CHILDREN),
+static WORD_SPECIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -36586,12 +36586,12 @@ pub static WORD_SPECIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_SPECF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECF_CHILDREN),
+static WORD_SPECF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -36641,12 +36641,12 @@ pub static WORD_SPECF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SPECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECE_CHILDREN),
+static WORD_SPECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECE_CHILDREN),
     value: Some(&["space", "spice"]),
 };
 
-pub static WORD_SPECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fic"),
         dictgen::InsensitiveStr::Ascii("fically"),
@@ -36670,12 +36670,12 @@ pub static WORD_SPECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_SPECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPECA_CHILDREN),
+static WORD_SPECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("il"),
         dictgen::InsensitiveStr::Ascii("ilist"),
@@ -36715,12 +36715,12 @@ pub static WORD_SPECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_SPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPEA_CHILDREN),
+static WORD_SPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -36758,12 +36758,12 @@ pub static WORD_SPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPC_CHILDREN),
+static WORD_SPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -36797,12 +36797,12 @@ pub static WORD_SPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SPA_CHILDREN),
+static WORD_SPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cebr"),
         dictgen::InsensitiveStr::Ascii("cegoat"),
@@ -36924,12 +36924,12 @@ pub static WORD_SPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_SO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SO_CHILDREN),
+static WORD_SO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SO_CHILDREN),
     value: None,
 };
 
-static WORD_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SOA_NODE),
     Some(&WORD_SOB_NODE),
     Some(&WORD_SOC_NODE),
@@ -36958,23 +36958,23 @@ static WORD_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOW_CHILDREN),
+static WORD_SOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["sow"]],
     range: 1..=1,
 };
 
-static WORD_SOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOV_CHILDREN),
+static WORD_SOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eits"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -37032,12 +37032,12 @@ pub static WORD_SOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_SOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SOU_CHILDREN),
+static WORD_SOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SOU_CHILDREN),
     value: None,
 };
 
-static WORD_SOU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SOU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SOUB_NODE),
     Some(&WORD_SOUC_NODE),
@@ -37066,12 +37066,12 @@ static WORD_SOU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUV_CHILDREN),
+static WORD_SOUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enier"),
         dictgen::InsensitiveStr::Ascii("eniers"),
@@ -37095,12 +37095,12 @@ pub static WORD_SOUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_SOUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUT_CHILDREN),
+static WORD_SOUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hampon"),
         dictgen::InsensitiveStr::Ascii("hamption"),
@@ -37146,23 +37146,23 @@ pub static WORD_SOUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SOUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUS_CHILDREN),
+static WORD_SOUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("traction")],
     values: &[&["subtraction"]],
     range: 8..=8,
 };
 
-static WORD_SOUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUR_CHILDREN),
+static WORD_SOUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("braten"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -37206,12 +37206,12 @@ pub static WORD_SOUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SOUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUN_CHILDREN),
+static WORD_SOUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dard"),
         dictgen::InsensitiveStr::Ascii("drtack"),
@@ -37237,12 +37237,12 @@ pub static WORD_SOUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SOUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUL_CHILDREN),
+static WORD_SOUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -37252,12 +37252,12 @@ pub static WORD_SOUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SOUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUD_CHILDREN),
+static WORD_SOUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -37267,12 +37267,12 @@ pub static WORD_SOUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SOUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUC_CHILDREN),
+static WORD_SOUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -37290,23 +37290,23 @@ pub static WORD_SOUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_SOUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOUB_CHILDREN),
+static WORD_SOUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["double"]],
     range: 2..=2,
 };
 
-static WORD_SOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOT_CHILDREN),
+static WORD_SOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erd"),
         dictgen::InsensitiveStr::Ascii("fware"),
@@ -37338,23 +37338,23 @@ pub static WORD_SOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOS_CHILDREN),
+static WORD_SOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cket")],
     values: &[&["socket"]],
     range: 4..=4,
 };
 
-static WORD_SOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOR_CHILDREN),
+static WORD_SOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cercy"),
@@ -37400,12 +37400,12 @@ pub static WORD_SOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOP_CHILDREN),
+static WORD_SOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arnos"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -37447,12 +37447,12 @@ pub static WORD_SOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOO_CHILDREN),
+static WORD_SOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aside"),
         dictgen::InsensitiveStr::Ascii("donim"),
@@ -37486,12 +37486,12 @@ pub static WORD_SOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_SON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SON_CHILDREN),
+static WORD_SON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SON_CHILDREN),
     value: None,
 };
 
-pub static WORD_SON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ething"),
         dictgen::InsensitiveStr::Ascii("glar"),
@@ -37511,12 +37511,12 @@ pub static WORD_SON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SOM_CHILDREN),
+static WORD_SOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SOM_CHILDREN),
     value: Some(&["some"]),
 };
 
-static WORD_SOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SOM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SOMA_NODE),
     None,
     None,
@@ -37545,12 +37545,12 @@ static WORD_SOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOMW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMW_CHILDREN),
+static WORD_SOMW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hat"),
         dictgen::InsensitiveStr::Ascii("here"),
@@ -37561,12 +37561,12 @@ pub static WORD_SOMW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SOMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMT_CHILDREN),
+static WORD_SOMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hign"),
         dictgen::InsensitiveStr::Ascii("hing"),
@@ -37584,12 +37584,12 @@ pub static WORD_SOMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SOMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMO_CHILDREN),
+static WORD_SOMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enes"),
         dictgen::InsensitiveStr::Ascii("ne"),
@@ -37598,23 +37598,23 @@ pub static WORD_SOMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SOMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMM_CHILDREN),
+static WORD_SOMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["some"]],
     range: 1..=1,
 };
 
-static WORD_SOME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SOME_CHILDREN),
+static WORD_SOME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SOME_CHILDREN),
     value: None,
 };
 
-static WORD_SOME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SOME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_SOMEB_NODE),
     None,
@@ -37643,12 +37643,12 @@ static WORD_SOME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOMEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEW_CHILDREN),
+static WORD_SOMEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aht"),
         dictgen::InsensitiveStr::Ascii("ere"),
@@ -37659,12 +37659,12 @@ pub static WORD_SOMEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SOMET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMET_CHILDREN),
+static WORD_SOMET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hibng"),
         dictgen::InsensitiveStr::Ascii("hig"),
@@ -37762,23 +37762,23 @@ pub static WORD_SOMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SOMES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMES_CHILDREN),
+static WORD_SOMES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMES_CHILDREN),
     value: Some(&["some", "sums"]),
 };
 
-pub static WORD_SOMES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SOMEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEO_CHILDREN),
+static WORD_SOMEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ene"),
@@ -37800,12 +37800,12 @@ pub static WORD_SOMEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SOMEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEN_CHILDREN),
+static WORD_SOMEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("one"),
@@ -37814,12 +37814,12 @@ pub static WORD_SOMEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_SOMEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEH_CHILDREN),
+static WORD_SOMEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ere"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -37845,34 +37845,34 @@ pub static WORD_SOMEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SOMEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEG_CHILDREN),
+static WORD_SOMEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hing")],
     values: &[&["something"]],
     range: 4..=4,
 };
 
-static WORD_SOMEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMEB_CHILDREN),
+static WORD_SOMEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oby")],
     values: &[&["somebody"]],
     range: 3..=3,
 };
 
-static WORD_SOMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOMA_CHILDREN),
+static WORD_SOMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ila"),
         dictgen::InsensitiveStr::Ascii("lija"),
@@ -37881,12 +37881,12 @@ pub static WORD_SOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOL_CHILDREN),
+static WORD_SOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("armutx"),
         dictgen::InsensitiveStr::Ascii("ataire"),
@@ -37994,12 +37994,12 @@ pub static WORD_SOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_SOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOK_CHILDREN),
+static WORD_SOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -38009,12 +38009,12 @@ pub static WORD_SOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_SOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOI_CHILDREN),
+static WORD_SOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("ld"),
@@ -38032,12 +38032,12 @@ pub static WORD_SOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOH_CHILDREN),
+static WORD_SOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pisticated"),
         dictgen::InsensitiveStr::Ascii("pomore"),
@@ -38047,12 +38047,12 @@ pub static WORD_SOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_SOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOF_CHILDREN),
+static WORD_SOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isticated"),
         dictgen::InsensitiveStr::Ascii("lty"),
@@ -38086,12 +38086,12 @@ pub static WORD_SOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOE_CHILDREN),
+static WORD_SOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cialize"),
         dictgen::InsensitiveStr::Ascii("m"),
@@ -38113,12 +38113,12 @@ pub static WORD_SOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOD_CHILDREN),
+static WORD_SOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("dered"),
@@ -38138,12 +38138,12 @@ pub static WORD_SOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SOC_CHILDREN),
+static WORD_SOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SOC_CHILDREN),
     value: None,
 };
 
-static WORD_SOC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SOC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SOCA_NODE),
     None,
     None,
@@ -38172,23 +38172,23 @@ static WORD_SOC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SOCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCT_CHILDREN),
+static WORD_SOCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tish")],
     values: &[&["scottish"]],
     range: 4..=4,
 };
 
-static WORD_SOCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCR_CHILDREN),
+static WORD_SOCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atease"),
         dictgen::InsensitiveStr::Ascii("atees"),
@@ -38212,23 +38212,23 @@ pub static WORD_SOCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SOCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCK_CHILDREN),
+static WORD_SOCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etted")],
     values: &[&["socketed"]],
     range: 5..=5,
 };
 
-static WORD_SOCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCI_CHILDREN),
+static WORD_SOCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alicing"),
         dictgen::InsensitiveStr::Ascii("alim"),
@@ -38320,12 +38320,12 @@ pub static WORD_SOCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SOCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCE_CHILDREN),
+static WORD_SOCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ities"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -38335,12 +38335,12 @@ pub static WORD_SOCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SOCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOCA_CHILDREN),
+static WORD_SOCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("il"),
         dictgen::InsensitiveStr::Ascii("ilism"),
@@ -38372,12 +38372,12 @@ pub static WORD_SOCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOB_CHILDREN),
+static WORD_SOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erity"),
         dictgen::InsensitiveStr::Ascii("reity"),
@@ -38386,23 +38386,23 @@ pub static WORD_SOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_SOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SOA_CHILDREN),
+static WORD_SOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lris")],
     values: &[&["solaris"]],
     range: 4..=4,
 };
 
-static WORD_SN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SN_CHILDREN),
+static WORD_SN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adler"),
         dictgen::InsensitiveStr::Ascii("adstorm"),
@@ -38512,12 +38512,12 @@ pub static WORD_SN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SM_CHILDREN),
+static WORD_SM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ackdwon"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -38589,12 +38589,12 @@ pub static WORD_SM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_SL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SL_CHILDREN),
+static WORD_SL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SL_CHILDREN),
     value: None,
 };
 
-static WORD_SL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SLA_NODE),
     None,
     Some(&WORD_SLC_NODE),
@@ -38623,12 +38623,12 @@ static WORD_SL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLU_CHILDREN),
+static WORD_SLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aghter"),
         dictgen::InsensitiveStr::Ascii("aghtered"),
@@ -38644,23 +38644,23 @@ pub static WORD_SLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_SLQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLQ_CHILDREN),
+static WORD_SLQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLQ_CHILDREN),
     value: Some(&["sql"]),
 };
 
-pub static WORD_SLQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLO_CHILDREN),
+static WORD_SLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gen"),
         dictgen::InsensitiveStr::Ascii("oth"),
@@ -38688,23 +38688,23 @@ pub static WORD_SLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_SLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLL_CHILDREN),
+static WORD_SLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ocation")],
     values: &[&["allocation"]],
     range: 7..=7,
 };
 
-static WORD_SLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLI_CHILDREN),
+static WORD_SLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -38754,23 +38754,23 @@ pub static WORD_SLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLG_CHILDREN),
+static WORD_SLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("htly")],
     values: &[&["slightly"]],
     range: 4..=4,
 };
 
-static WORD_SLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLE_CHILDREN),
+static WORD_SLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -38804,34 +38804,34 @@ pub static WORD_SLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SLD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLD_CHILDREN),
+static WORD_SLD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iers")],
     values: &[&["sliders"]],
     range: 4..=4,
 };
 
-static WORD_SLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLC_CHILDREN),
+static WORD_SLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["slices"]],
     range: 3..=3,
 };
 
-static WORD_SLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SLA_CHILDREN),
+static WORD_SLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -38875,12 +38875,12 @@ pub static WORD_SLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_SK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SK_CHILDREN),
+static WORD_SK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SK_CHILDREN),
     value: None,
 };
 
-static WORD_SK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SK_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SKA_NODE),
     None,
     None,
@@ -38909,12 +38909,12 @@ static WORD_SK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SKY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKY_CHILDREN),
+static WORD_SKY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("walkr"),
@@ -38923,12 +38923,12 @@ pub static WORD_SKY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SKW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKW_CHILDREN),
+static WORD_SKW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alk"),
         dictgen::InsensitiveStr::Ascii("alked"),
@@ -38946,12 +38946,12 @@ pub static WORD_SKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SKU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKU_CHILDREN),
+static WORD_SKU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("rge"),
@@ -38969,12 +38969,12 @@ pub static WORD_SKU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SKT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKT_CHILDREN),
+static WORD_SKT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eches"),
         dictgen::InsensitiveStr::Ascii("echy"),
@@ -38983,12 +38983,12 @@ pub static WORD_SKT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_SKR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKR_CHILDREN),
+static WORD_SKR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("awberries"),
         dictgen::InsensitiveStr::Ascii("imish"),
@@ -38997,12 +38997,12 @@ pub static WORD_SKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_SKP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKP_CHILDREN),
+static WORD_SKP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etic"),
         dictgen::InsensitiveStr::Ascii("eticism"),
@@ -39012,12 +39012,12 @@ pub static WORD_SKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SKO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKO_CHILDREN),
+static WORD_SKO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ol"),
         dictgen::InsensitiveStr::Ascii("oled"),
@@ -39035,12 +39035,12 @@ pub static WORD_SKO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SKI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKI_CHILDREN),
+static WORD_SKI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfull"),
         dictgen::InsensitiveStr::Ascii("llfull"),
@@ -39102,12 +39102,12 @@ pub static WORD_SKI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SKE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKE_CHILDREN),
+static WORD_SKE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cth"),
         dictgen::InsensitiveStr::Ascii("cthes"),
@@ -39179,12 +39179,12 @@ pub static WORD_SKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SKA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SKA_CHILDREN),
+static WORD_SKA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SKA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SKA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gerak"),
         dictgen::InsensitiveStr::Ascii("lar"),
@@ -39220,12 +39220,12 @@ pub static WORD_SKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_SI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SI_CHILDREN),
+static WORD_SI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SI_CHILDREN),
     value: None,
 };
 
-static WORD_SI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIA_NODE),
     Some(&WORD_SIB_NODE),
     Some(&WORD_SIC_NODE),
@@ -39254,12 +39254,12 @@ static WORD_SI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIZ_NODE),
 ];
 
-static WORD_SIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIZ_CHILDREN),
+static WORD_SIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIZ_CHILDREN),
     value: Some(&["six", "size"]),
 };
 
-pub static WORD_SIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebale"),
         dictgen::InsensitiveStr::Ascii("eble"),
@@ -39289,23 +39289,23 @@ pub static WORD_SIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=14,
 };
 
-static WORD_SIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIX_CHILDREN),
+static WORD_SIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tin")],
     values: &[&["sistine", "sixteen"]],
     range: 3..=3,
 };
 
-static WORD_SIW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIW_CHILDREN),
+static WORD_SIW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tch"),
         dictgen::InsensitiveStr::Ascii("tched"),
@@ -39316,12 +39316,12 @@ pub static WORD_SIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIV_CHILDREN),
+static WORD_SIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -39341,12 +39341,12 @@ pub static WORD_SIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_SIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIU_CHILDREN),
+static WORD_SIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tational"),
@@ -39356,12 +39356,12 @@ pub static WORD_SIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIT_CHILDREN),
+static WORD_SIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -39441,12 +39441,12 @@ pub static WORD_SIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_SIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIS_CHILDREN),
+static WORD_SIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("nce"),
@@ -39510,12 +39510,12 @@ pub static WORD_SIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_SIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIR_CHILDREN),
+static WORD_SIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cle"),
         dictgen::InsensitiveStr::Ascii("cles"),
@@ -39587,12 +39587,12 @@ pub static WORD_SIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_SIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIP_CHILDREN),
+static WORD_SIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ly"),
         dictgen::InsensitiveStr::Ascii("plies"),
@@ -39601,12 +39601,12 @@ pub static WORD_SIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIO_CHILDREN),
+static WORD_SIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nist"),
         dictgen::InsensitiveStr::Ascii("nists"),
@@ -39615,12 +39615,12 @@ pub static WORD_SIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_SIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SIN_CHILDREN),
+static WORD_SIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SIN_CHILDREN),
     value: None,
 };
 
-static WORD_SIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SINA_NODE),
     None,
     Some(&WORD_SINC_NODE),
@@ -39649,12 +39649,12 @@ static WORD_SIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINT_CHILDREN),
+static WORD_SINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ac"),
         dictgen::InsensitiveStr::Ascii("acks"),
@@ -39682,12 +39682,12 @@ pub static WORD_SINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINS_CHILDREN),
+static WORD_SINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("iter"),
@@ -39696,23 +39696,23 @@ pub static WORD_SINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SINP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINP_CHILDREN),
+static WORD_SINP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["simply"]],
     range: 2..=2,
 };
 
-static WORD_SINO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINO_CHILDREN),
+static WORD_SINO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("id"),
         dictgen::InsensitiveStr::Ascii("idal"),
@@ -39722,12 +39722,12 @@ pub static WORD_SINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SINN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINN_CHILDREN),
+static WORD_SINN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agog"),
         dictgen::InsensitiveStr::Ascii("agogs"),
@@ -39749,12 +39749,12 @@ pub static WORD_SINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SINL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINL_CHILDREN),
+static WORD_SINL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("geplayer"),
@@ -39764,12 +39764,12 @@ pub static WORD_SINL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_SINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINI_CHILDREN),
+static WORD_SINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cal"),
@@ -39791,12 +39791,12 @@ pub static WORD_SINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SING_CHILDREN),
+static WORD_SING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SING_CHILDREN),
     value: None,
 };
 
-pub static WORD_SING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -39922,23 +39922,23 @@ pub static WORD_SING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_SIND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIND_CHILDREN),
+static WORD_SIND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIND_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["since"]],
     range: 1..=1,
 };
 
-static WORD_SINC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINC_CHILDREN),
+static WORD_SINC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eer"),
         dictgen::InsensitiveStr::Ascii("ereley"),
@@ -39956,12 +39956,12 @@ pub static WORD_SINC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SINA_CHILDREN),
+static WORD_SINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gog"),
         dictgen::InsensitiveStr::Ascii("gogs"),
@@ -39972,12 +39972,12 @@ pub static WORD_SINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SIM_CHILDREN),
+static WORD_SIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SIM_CHILDREN),
     value: None,
 };
 
-static WORD_SIM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SIM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIMA_NODE),
     None,
     None,
@@ -40006,12 +40006,12 @@ static WORD_SIM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SIMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMU_CHILDREN),
+static WORD_SIMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alte"),
         dictgen::InsensitiveStr::Ascii("alted"),
@@ -40133,23 +40133,23 @@ pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_SIMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMS_CHILDREN),
+static WORD_SIMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pon")],
     values: &[&["simpson"]],
     range: 3..=3,
 };
 
-static WORD_SIMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SIMP_CHILDREN),
+static WORD_SIMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SIMP_CHILDREN),
     value: None,
 };
 
-static WORD_SIMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SIMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIMPA_NODE),
     None,
     None,
@@ -40178,23 +40178,23 @@ static WORD_SIMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SIMPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPY_CHILDREN),
+static WORD_SIMPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPY_CHILDREN),
     value: Some(&["simply"]),
 };
 
-pub static WORD_SIMPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SIMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPT_CHILDREN),
+static WORD_SIMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("om"),
         dictgen::InsensitiveStr::Ascii("omatic"),
@@ -40230,23 +40230,23 @@ pub static WORD_SIMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SIMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPO_CHILDREN),
+static WORD_SIMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sn")],
     values: &[&["simpson"]],
     range: 2..=2,
 };
 
-static WORD_SIMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPL_CHILDREN),
+static WORD_SIMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efying"),
         dictgen::InsensitiveStr::Ascii("ei"),
@@ -40338,12 +40338,12 @@ pub static WORD_SIMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SIMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPI_CHILDREN),
+static WORD_SIMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("city"),
         dictgen::InsensitiveStr::Ascii("fication"),
@@ -40363,34 +40363,34 @@ pub static WORD_SIMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SIMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPE_CHILDREN),
+static WORD_SIMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lst")],
     values: &[&["simplest"]],
     range: 3..=3,
 };
 
-static WORD_SIMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMPA_CHILDREN),
+static WORD_SIMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("thizers")],
     values: &[&["sympathizers"]],
     range: 7..=7,
 };
 
-static WORD_SIMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMM_CHILDREN),
+static WORD_SIMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etric"),
         dictgen::InsensitiveStr::Ascii("etrical"),
@@ -40412,12 +40412,12 @@ pub static WORD_SIMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_SIML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIML_CHILDREN),
+static WORD_SIML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIML_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("arlity"),
@@ -40473,12 +40473,12 @@ pub static WORD_SIML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SIMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMI_CHILDREN),
+static WORD_SIMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alir"),
         dictgen::InsensitiveStr::Ascii("alr"),
@@ -40562,23 +40562,23 @@ pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SIMG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMG_CHILDREN),
+static WORD_SIMG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["single"]],
     range: 2..=2,
 };
 
-static WORD_SIME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIME_CHILDREN),
+static WORD_SIME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIME_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ltaneous"),
         dictgen::InsensitiveStr::Ascii("ltaneously"),
@@ -40606,12 +40606,12 @@ pub static WORD_SIME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SIMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIMA_CHILDREN),
+static WORD_SIMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ltaneous"),
         dictgen::InsensitiveStr::Ascii("ltaneously"),
@@ -40620,12 +40620,12 @@ pub static WORD_SIMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_SIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIL_CHILDREN),
+static WORD_SIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abus"),
         dictgen::InsensitiveStr::Ascii("abuses"),
@@ -40749,23 +40749,23 @@ pub static WORD_SIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_SIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIH_CHILDREN),
+static WORD_SIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("louette")],
     values: &[&["silhouette"]],
     range: 7..=7,
 };
 
-static WORD_SIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SIG_CHILDREN),
+static WORD_SIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SIG_CHILDREN),
     value: None,
 };
 
-static WORD_SIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SIG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SIGA_NODE),
     None,
     None,
@@ -40794,12 +40794,12 @@ static WORD_SIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SIGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGU_CHILDREN),
+static WORD_SIGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ret"),
         dictgen::InsensitiveStr::Ascii("rete"),
@@ -40817,23 +40817,23 @@ pub static WORD_SIGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SIGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGT_CHILDREN),
+static WORD_SIGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hstone")],
     values: &[&["sightstone"]],
     range: 6..=6,
 };
 
-static WORD_SIGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGR_CHILDREN),
+static WORD_SIGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ynge"),
         dictgen::InsensitiveStr::Ascii("ynges"),
@@ -40842,12 +40842,12 @@ pub static WORD_SIGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_SIGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGN_CHILDREN),
+static WORD_SIGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abl"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -40967,12 +40967,12 @@ pub static WORD_SIGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SIGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGL_CHILDREN),
+static WORD_SIGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -40982,12 +40982,12 @@ pub static WORD_SIGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SIGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGI_CHILDREN),
+static WORD_SIGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ficance"),
         dictgen::InsensitiveStr::Ascii("ficant"),
@@ -41011,12 +41011,12 @@ pub static WORD_SIGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_SIGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGH_CHILDREN),
+static WORD_SIGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("rynge"),
@@ -41036,23 +41036,23 @@ pub static WORD_SIGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SIGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGE_CHILDREN),
+static WORD_SIGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("n")],
     values: &[&["sign"]],
     range: 1..=1,
 };
 
-static WORD_SIGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIGA_CHILDREN),
+static WORD_SIGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -41076,12 +41076,12 @@ pub static WORD_SIGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIF_CHILDREN),
+static WORD_SIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fix"),
         dictgen::InsensitiveStr::Ascii("fixation"),
@@ -41099,12 +41099,12 @@ pub static WORD_SIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_SIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIE_CHILDREN),
+static WORD_SIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIE_CHILDREN),
     value: Some(&["size", "sigh", "side"]),
 };
 
-pub static WORD_SIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nce"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -41132,12 +41132,12 @@ pub static WORD_SIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SID_CHILDREN),
+static WORD_SID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SID_CHILDREN),
     value: None,
 };
 
-pub static WORD_SID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ebaord"),
@@ -41165,12 +41165,12 @@ pub static WORD_SID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIC_CHILDREN),
+static WORD_SIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("inct"),
@@ -41190,12 +41190,12 @@ pub static WORD_SIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIB_CHILDREN),
+static WORD_SIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iling"),
         dictgen::InsensitiveStr::Ascii("ilings"),
@@ -41213,23 +41213,23 @@ pub static WORD_SIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_SIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SIA_CHILDREN),
+static WORD_SIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["said"]],
     range: 1..=1,
 };
 
-static WORD_SH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SH_CHILDREN),
+static WORD_SH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SH_CHILDREN),
     value: None,
 };
 
-static WORD_SH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SHA_NODE),
     Some(&WORD_SHB_NODE),
     Some(&WORD_SHC_NODE),
@@ -41258,12 +41258,12 @@ static WORD_SH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHY_CHILDREN),
+static WORD_SHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stem"),
         dictgen::InsensitiveStr::Ascii("stemerror"),
@@ -41281,12 +41281,12 @@ pub static WORD_SHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_SHW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHW_CHILDREN),
+static WORD_SHW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ashank"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -41297,12 +41297,12 @@ pub static WORD_SHW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHU_CHILDREN),
+static WORD_SHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("down"),
         dictgen::InsensitiveStr::Ascii("fle"),
@@ -41336,12 +41336,12 @@ pub static WORD_SHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHT_CHILDREN),
+static WORD_SHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iless"),
         dictgen::InsensitiveStr::Ascii("op"),
@@ -41369,23 +41369,23 @@ pub static WORD_SHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SHS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHS_CHILDREN),
+static WORD_SHS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHS_CHILDREN),
     value: Some(&["nhs", "ssh"]),
 };
 
-pub static WORD_SHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pe")],
     values: &[&["shape"]],
     range: 2..=2,
 };
 
-static WORD_SHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHR_CHILDREN),
+static WORD_SHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apenl"),
         dictgen::InsensitiveStr::Ascii("eak"),
@@ -41411,12 +41411,12 @@ pub static WORD_SHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SHP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHP_CHILDREN),
+static WORD_SHP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -41442,12 +41442,12 @@ pub static WORD_SHP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SHO_CHILDREN),
+static WORD_SHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SHO_CHILDREN),
     value: None,
 };
 
-static WORD_SHO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SHO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -41476,12 +41476,12 @@ static WORD_SHO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SHOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOW_CHILDREN),
+static WORD_SHOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("boarding"),
         dictgen::InsensitiveStr::Ascii("ede"),
@@ -41499,12 +41499,12 @@ pub static WORD_SHOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SHOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOU_CHILDREN),
+static WORD_SHOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cl"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -41570,12 +41570,12 @@ pub static WORD_SHOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SHOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOT_CHILDREN),
+static WORD_SHOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cut"),
         dictgen::InsensitiveStr::Ascii("cuts"),
@@ -41586,12 +41586,12 @@ pub static WORD_SHOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SHOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOR_CHILDREN),
+static WORD_SHOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cut"),
         dictgen::InsensitiveStr::Ascii("cuts"),
@@ -41639,12 +41639,12 @@ pub static WORD_SHOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SHOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOP_CHILDREN),
+static WORD_SHOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("keeepers"),
@@ -41654,23 +41654,23 @@ pub static WORD_SHOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SHOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOO_CHILDREN),
+static WORD_SHOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uld")],
     values: &[&["should"]],
     range: 3..=3,
 };
 
-static WORD_SHOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOL_CHILDREN),
+static WORD_SHOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -41680,12 +41680,12 @@ pub static WORD_SHOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_SHOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOI_CHILDREN),
+static WORD_SHOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -41694,12 +41694,12 @@ pub static WORD_SHOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=2,
 };
 
-static WORD_SHOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHOF_CHILDREN),
+static WORD_SHOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tware"),
@@ -41708,23 +41708,23 @@ pub static WORD_SHOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SHN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHN_CHILDREN),
+static WORD_SHN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aghai")],
     values: &[&["shanghai"]],
     range: 5..=5,
 };
 
-static WORD_SHL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHL_CHILDREN),
+static WORD_SHL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edon"),
         dictgen::InsensitiveStr::Ascii("eter"),
@@ -41742,12 +41742,12 @@ pub static WORD_SHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHI_CHILDREN),
+static WORD_SHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cane"),
         dictgen::InsensitiveStr::Ascii("eldd"),
@@ -41799,12 +41799,12 @@ pub static WORD_SHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SHF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHF_CHILDREN),
+static WORD_SHF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("ited"),
@@ -41824,12 +41824,12 @@ pub static WORD_SHF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_SHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SHE_CHILDREN),
+static WORD_SHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SHE_CHILDREN),
     value: None,
 };
 
-static WORD_SHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SHE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SHEA_NODE),
     Some(&WORD_SHEB_NODE),
     Some(&WORD_SHEC_NODE),
@@ -41858,23 +41858,23 @@ static WORD_SHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SHEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEV_CHILDREN),
+static WORD_SHEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("les")],
     values: &[&["shelves"]],
     range: 3..=3,
 };
 
-static WORD_SHET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHET_CHILDREN),
+static WORD_SHET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ler"),
         dictgen::InsensitiveStr::Ascii("lers"),
@@ -41883,12 +41883,12 @@ pub static WORD_SHET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SHER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHER_CHILDREN),
+static WORD_SHER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHER_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("if"),
         dictgen::InsensitiveStr::Ascii("ifs"),
@@ -41899,12 +41899,12 @@ pub static WORD_SHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SHEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEP_CHILDREN),
+static WORD_SHEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("arded"),
@@ -41952,12 +41952,12 @@ pub static WORD_SHEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SHEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEN_CHILDREN),
+static WORD_SHEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adigans"),
         dictgen::InsensitiveStr::Ascii("anagans"),
@@ -41995,12 +41995,12 @@ pub static WORD_SHEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_SHEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEM_CHILDREN),
+static WORD_SHEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("atic"),
@@ -42010,12 +42010,12 @@ pub static WORD_SHEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SHEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEL_CHILDREN),
+static WORD_SHEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("terd"),
         dictgen::InsensitiveStr::Ascii("vers"),
@@ -42025,12 +42025,12 @@ pub static WORD_SHEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_SHEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEI_CHILDREN),
+static WORD_SHEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("lded"),
@@ -42041,12 +42041,12 @@ pub static WORD_SHEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SHEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEE_CHILDREN),
+static WORD_SHEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lpe"),
         dictgen::InsensitiveStr::Ascii("pel"),
@@ -42064,12 +42064,12 @@ pub static WORD_SHEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SHED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHED_CHILDREN),
+static WORD_SHED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHED_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ule"),
         dictgen::InsensitiveStr::Ascii("uled"),
@@ -42087,12 +42087,12 @@ pub static WORD_SHED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SHEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEC_CHILDREN),
+static WORD_SHEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("k"),
         dictgen::InsensitiveStr::Ascii("ked"),
@@ -42110,23 +42110,23 @@ pub static WORD_SHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SHEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEB_CHILDREN),
+static WORD_SHEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eng")],
     values: &[&["shebang"]],
     range: 3..=3,
 };
 
-static WORD_SHEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHEA_CHILDREN),
+static WORD_SHEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kspeare"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -42135,12 +42135,12 @@ pub static WORD_SHEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SHC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHC_CHILDREN),
+static WORD_SHC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edule"),
         dictgen::InsensitiveStr::Ascii("emes"),
@@ -42160,23 +42160,23 @@ pub static WORD_SHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_SHB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHB_CHILDREN),
+static WORD_SHB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ang")],
     values: &[&["shebang"]],
     range: 3..=3,
 };
 
-static WORD_SHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SHA_CHILDREN),
+static WORD_SHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SHA_CHILDREN),
     value: None,
 };
 
-static WORD_SHA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SHA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -42205,12 +42205,12 @@ static WORD_SHA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SHAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAW_CHILDREN),
+static WORD_SHAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hsank"),
         dictgen::InsensitiveStr::Ascii("shak"),
@@ -42219,12 +42219,12 @@ pub static WORD_SHAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_SHAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAT_CHILDREN),
+static WORD_SHAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nering"),
         dictgen::InsensitiveStr::Ascii("ow"),
@@ -42244,23 +42244,23 @@ pub static WORD_SHAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SHAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAS_CHILDREN),
+static WORD_SHAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hes")],
     values: &[&["slashes"]],
     range: 3..=3,
 };
 
-static WORD_SHAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAR_CHILDREN),
+static WORD_SHAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dholders"),
         dictgen::InsensitiveStr::Ascii("eed"),
@@ -42304,12 +42304,12 @@ pub static WORD_SHAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SHAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAP_CHILDREN),
+static WORD_SHAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ening"),
         dictgen::InsensitiveStr::Ascii("rening"),
@@ -42337,12 +42337,12 @@ pub static WORD_SHAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SHAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAO_CHILDREN),
+static WORD_SHAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dw"),
         dictgen::InsensitiveStr::Ascii("dws"),
@@ -42351,12 +42351,12 @@ pub static WORD_SHAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_SHAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAN_CHILDREN),
+static WORD_SHAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deleer"),
         dictgen::InsensitiveStr::Ascii("deleers"),
@@ -42390,12 +42390,12 @@ pub static WORD_SHAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SHAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAM_CHILDREN),
+static WORD_SHAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elesly"),
         dictgen::InsensitiveStr::Ascii("elessely"),
@@ -42415,23 +42415,23 @@ pub static WORD_SHAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_SHAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAL_CHILDREN),
+static WORD_SHAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAL_CHILDREN),
     value: Some(&["shall"]),
 };
 
-pub static WORD_SHAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SHAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAK_CHILDREN),
+static WORD_SHAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eapeare"),
         dictgen::InsensitiveStr::Ascii("epseare"),
@@ -42453,23 +42453,23 @@ pub static WORD_SHAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_SHAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAE_CHILDREN),
+static WORD_SHAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rd")],
     values: &[&["shared", "shard"]],
     range: 2..=2,
 };
 
-static WORD_SHAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SHAD_CHILDREN),
+static WORD_SHAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SHAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SHAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SHAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asloo"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -42487,34 +42487,34 @@ pub static WORD_SHAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SG_CHILDREN),
+static WORD_SG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("adow")],
     values: &[&["shadow"]],
     range: 4..=4,
 };
 
-static WORD_SF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SF_CHILDREN),
+static WORD_SF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ety")],
     values: &[&["safety"]],
     range: 3..=3,
 };
 
-static WORD_SE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SE_CHILDREN),
+static WORD_SE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SE_CHILDREN),
     value: None,
 };
 
-static WORD_SE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SEA_NODE),
     Some(&WORD_SEB_NODE),
     Some(&WORD_SEC_NODE),
@@ -42543,12 +42543,12 @@ static WORD_SE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SEZ_NODE),
 ];
 
-static WORD_SEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEZ_CHILDREN),
+static WORD_SEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iure"),
         dictgen::InsensitiveStr::Ascii("iures"),
@@ -42558,12 +42558,12 @@ pub static WORD_SEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_SEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEX_CHILDREN),
+static WORD_SEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aulized"),
         dictgen::InsensitiveStr::Ascii("aully"),
@@ -42591,12 +42591,12 @@ pub static WORD_SEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_SEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEW_CHILDREN),
+static WORD_SEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("donim"),
         dictgen::InsensitiveStr::Ascii("donims"),
@@ -42606,12 +42606,12 @@ pub static WORD_SEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_SEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEV_CHILDREN),
+static WORD_SEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aral"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -42671,12 +42671,12 @@ pub static WORD_SEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_SEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEU_CHILDREN),
+static WORD_SEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ences"),
@@ -42694,12 +42694,12 @@ pub static WORD_SEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SET_CHILDREN),
+static WORD_SET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("evn"),
         dictgen::InsensitiveStr::Ascii("git"),
@@ -42785,12 +42785,12 @@ pub static WORD_SET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SES_CHILDREN),
+static WORD_SES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SES_CHILDREN),
     value: None,
 };
 
-pub static WORD_SES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cede"),
         dictgen::InsensitiveStr::Ascii("ceded"),
@@ -42852,12 +42852,12 @@ pub static WORD_SES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SER_CHILDREN),
+static WORD_SER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SER_CHILDREN),
     value: Some(&["set"]),
 };
 
-static WORD_SER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SERA_NODE),
     Some(&WORD_SERB_NODE),
     Some(&WORD_SERC_NODE),
@@ -42886,23 +42886,23 @@ static WORD_SER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERW_CHILDREN),
+static WORD_SERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["server", "sewer"]],
     range: 2..=2,
 };
 
-static WORD_SERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERV_CHILDREN),
+static WORD_SERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ans"),
         dictgen::InsensitiveStr::Ascii("antes"),
@@ -43000,12 +43000,12 @@ pub static WORD_SERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_SERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERT_CHILDREN),
+static WORD_SERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ificate"),
         dictgen::InsensitiveStr::Ascii("ificated"),
@@ -43021,23 +43021,23 @@ pub static WORD_SERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_SERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERS_CHILDREN),
+static WORD_SERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["series"]],
     range: 3..=3,
 };
 
-static WORD_SERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERR_CHILDREN),
+static WORD_SERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebral"),
         dictgen::InsensitiveStr::Ascii("ebrally"),
@@ -43046,12 +43046,12 @@ pub static WORD_SERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_SERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERO_CHILDREN),
+static WORD_SERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("und"),
         dictgen::InsensitiveStr::Ascii("unded"),
@@ -43067,12 +43067,12 @@ pub static WORD_SERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERI_CHILDREN),
+static WORD_SERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aized"),
         dictgen::InsensitiveStr::Ascii("alialisation"),
@@ -43188,12 +43188,12 @@ pub static WORD_SERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_SERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERG_CHILDREN),
+static WORD_SERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aent"),
         dictgen::InsensitiveStr::Ascii("eat"),
@@ -43211,12 +43211,12 @@ pub static WORD_SERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERE_CHILDREN),
+static WORD_SERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bral"),
         dictgen::InsensitiveStr::Ascii("brally"),
@@ -43244,12 +43244,12 @@ pub static WORD_SERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERC_CHILDREN),
+static WORD_SERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hable"),
@@ -43279,23 +43279,23 @@ pub static WORD_SERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERB_CHILDREN),
+static WORD_SERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ain")],
     values: &[&["serbian"]],
     range: 3..=3,
 };
 
-static WORD_SERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SERA_CHILDREN),
+static WORD_SERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -43363,12 +43363,12 @@ pub static WORD_SERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEQ_CHILDREN),
+static WORD_SEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -43480,12 +43480,12 @@ pub static WORD_SEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_SEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SEP_CHILDREN),
+static WORD_SEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SEP_CHILDREN),
     value: None,
 };
 
-static WORD_SEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SEP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SEPA_NODE),
     None,
     Some(&WORD_SEPC_NODE),
@@ -43514,12 +43514,12 @@ static WORD_SEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SEPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPU_CHILDREN),
+static WORD_SEPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lchraly"),
         dictgen::InsensitiveStr::Ascii("lchrlly"),
@@ -43537,12 +43537,12 @@ pub static WORD_SEPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SEPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPT_CHILDREN),
+static WORD_SEPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emer"),
         dictgen::InsensitiveStr::Ascii("meber"),
@@ -43551,12 +43551,12 @@ pub static WORD_SEPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_SEPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPR_CHILDREN),
+static WORD_SEPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aate"),
         dictgen::InsensitiveStr::Ascii("arate"),
@@ -43578,12 +43578,12 @@ pub static WORD_SEPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SEPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPP_CHILDREN),
+static WORD_SEPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("arations"),
@@ -43593,23 +43593,23 @@ pub static WORD_SEPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_SEPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPO_CHILDREN),
+static WORD_SEPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rate")],
     values: &[&["separate"]],
     range: 4..=4,
 };
 
-static WORD_SEPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPL_CHILDREN),
+static WORD_SEPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icural"),
         dictgen::InsensitiveStr::Ascii("icurally"),
@@ -43627,23 +43627,23 @@ pub static WORD_SEPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_SEPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPI_CHILDREN),
+static WORD_SEPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("na")],
     values: &[&["subpena"]],
     range: 2..=2,
 };
 
-static WORD_SEPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SEPE_CHILDREN),
+static WORD_SEPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SEPE_CHILDREN),
     value: None,
 };
 
-static WORD_SEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SEPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SEPEA_NODE),
     None,
     Some(&WORD_SEPEC_NODE),
@@ -43672,12 +43672,12 @@ static WORD_SEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SEPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPET_CHILDREN),
+static WORD_SEPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aror"),
         dictgen::InsensitiveStr::Ascii("arors"),
@@ -43697,12 +43697,12 @@ pub static WORD_SEPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SEPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPER_CHILDREN),
+static WORD_SEPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ad"),
@@ -43812,12 +43812,12 @@ pub static WORD_SEPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SEPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPEN_CHILDREN),
+static WORD_SEPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dent"),
@@ -43827,23 +43827,23 @@ pub static WORD_SEPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_SEPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPEI_CHILDREN),
+static WORD_SEPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cfy")],
     values: &[&["specify"]],
     range: 3..=3,
 };
 
-static WORD_SEPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPEC_CHILDREN),
+static WORD_SEPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("ially"),
@@ -43873,12 +43873,12 @@ pub static WORD_SEPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SEPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPEA_CHILDREN),
+static WORD_SEPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rable"),
         dictgen::InsensitiveStr::Ascii("rate"),
@@ -43928,12 +43928,12 @@ pub static WORD_SEPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SEPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPC_CHILDREN),
+static WORD_SEPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("ially"),
@@ -43965,12 +43965,12 @@ pub static WORD_SEPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SEPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEPA_CHILDREN),
+static WORD_SEPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("racion"),
@@ -44050,12 +44050,12 @@ pub static WORD_SEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEO_CHILDREN),
+static WORD_SEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("nds"),
@@ -44064,12 +44064,12 @@ pub static WORD_SEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_SEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SEN_CHILDREN),
+static WORD_SEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SEN_CHILDREN),
     value: None,
 };
 
-static WORD_SEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SENA_NODE),
     None,
     Some(&WORD_SENC_NODE),
@@ -44098,12 +44098,12 @@ static WORD_SEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SENZ_NODE),
 ];
 
-static WORD_SENZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENZ_CHILDREN),
+static WORD_SENZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ationalism"),
         dictgen::InsensitiveStr::Ascii("ationalist"),
@@ -44112,12 +44112,12 @@ pub static WORD_SENZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 10..=10,
 };
 
-static WORD_SENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENT_CHILDREN),
+static WORD_SENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amental"),
         dictgen::InsensitiveStr::Ascii("aments"),
@@ -44207,12 +44207,12 @@ pub static WORD_SENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_SENS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENS_CHILDREN),
+static WORD_SENS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -44332,34 +44332,34 @@ pub static WORD_SENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_SENQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENQ_CHILDREN),
+static WORD_SENQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uence")],
     values: &[&["sequence"]],
     range: 5..=5,
 };
 
-static WORD_SENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENO_CHILDREN),
+static WORD_SENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("irs")],
     values: &[&["seniors"]],
     range: 3..=3,
 };
 
-static WORD_SENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENI_CHILDREN),
+static WORD_SENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntels"),
         dictgen::InsensitiveStr::Ascii("ores"),
@@ -44381,23 +44381,23 @@ pub static WORD_SENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENF_CHILDREN),
+static WORD_SENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ile")],
     values: &[&["sendfile"]],
     range: 3..=3,
 };
 
-static WORD_SENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENE_CHILDREN),
+static WORD_SENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rio"),
         dictgen::InsensitiveStr::Ascii("rity"),
@@ -44406,12 +44406,12 @@ pub static WORD_SENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_SEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEND_CHILDREN),
+static WORD_SEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etary"),
         dictgen::InsensitiveStr::Ascii("ign"),
@@ -44422,12 +44422,12 @@ pub static WORD_SEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENC_CHILDREN),
+static WORD_SENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ond"),
@@ -44443,12 +44443,12 @@ pub static WORD_SENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SENA_CHILDREN),
+static WORD_SENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ireo"),
         dictgen::InsensitiveStr::Ascii("ireos"),
@@ -44474,12 +44474,12 @@ pub static WORD_SENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEM_CHILDREN),
+static WORD_SEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aintics"),
         dictgen::InsensitiveStr::Ascii("amphore"),
@@ -44577,12 +44577,12 @@ pub static WORD_SEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_SEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEL_CHILDREN),
+static WORD_SEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceted"),
         dictgen::InsensitiveStr::Ascii("cetion"),
@@ -44700,12 +44700,12 @@ pub static WORD_SEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_SEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEK_CHILDREN),
+static WORD_SEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -44715,12 +44715,12 @@ pub static WORD_SEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_SEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEI_CHILDREN),
+static WORD_SEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("na"),
@@ -44742,23 +44742,23 @@ pub static WORD_SEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_SEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEH_CHILDREN),
+static WORD_SEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEH_CHILDREN),
     value: Some(&["she"]),
 };
 
-pub static WORD_SEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ll")],
     values: &[&["sell", "shell"]],
     range: 2..=2,
 };
 
-static WORD_SEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEG_CHILDREN),
+static WORD_SEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("aults"),
@@ -44864,12 +44864,12 @@ pub static WORD_SEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_SEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEF_CHILDREN),
+static WORD_SEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lies"),
         dictgen::InsensitiveStr::Ascii("lishness"),
@@ -44878,12 +44878,12 @@ pub static WORD_SEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_SEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEE_CHILDREN),
+static WORD_SEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("em"),
@@ -44949,12 +44949,12 @@ pub static WORD_SEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_SED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SED_CHILDREN),
+static WORD_SED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SED_CHILDREN),
     value: None,
 };
 
-pub static WORD_SED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entarity"),
         dictgen::InsensitiveStr::Ascii("ereal"),
@@ -44976,12 +44976,12 @@ pub static WORD_SED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_SEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SEC_CHILDREN),
+static WORD_SEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SEC_CHILDREN),
     value: None,
 };
 
-static WORD_SEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_SECC_NODE),
@@ -45010,12 +45010,12 @@ static WORD_SEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECU_CHILDREN),
+static WORD_SECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -45067,12 +45067,12 @@ pub static WORD_SECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECT_CHILDREN),
+static WORD_SECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ins"),
@@ -45114,12 +45114,12 @@ pub static WORD_SECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECR_CHILDREN),
+static WORD_SECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atary"),
         dictgen::InsensitiveStr::Ascii("atery"),
@@ -45151,34 +45151,34 @@ pub static WORD_SECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SECQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECQ_CHILDREN),
+static WORD_SECQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uence")],
     values: &[&["sequence"]],
     range: 5..=5,
 };
 
-static WORD_SECP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECP_CHILDREN),
+static WORD_SECP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["scepter"]],
     range: 3..=3,
 };
 
-static WORD_SECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECO_CHILDREN),
+static WORD_SECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -45236,12 +45236,12 @@ pub static WORD_SECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_SECN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECN_CHILDREN),
+static WORD_SECN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -45250,23 +45250,23 @@ pub static WORD_SECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=1,
 };
 
-static WORD_SECL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECL_CHILDREN),
+static WORD_SECL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ector")],
     values: &[&["selector"]],
     range: 5..=5,
 };
 
-static WORD_SECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECI_CHILDREN),
+static WORD_SECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fic"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -45288,12 +45288,12 @@ pub static WORD_SECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_SECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECE_CHILDREN),
+static WORD_SECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eded"),
@@ -45313,12 +45313,12 @@ pub static WORD_SECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SECC_CHILDREN),
+static WORD_SECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eeded"),
         dictgen::InsensitiveStr::Ascii("ond"),
@@ -45336,12 +45336,12 @@ pub static WORD_SECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_SEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEB_CHILDREN),
+static WORD_SEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asitan"),
         dictgen::InsensitiveStr::Ascii("astain"),
@@ -45361,12 +45361,12 @@ pub static WORD_SEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SEA_CHILDREN),
+static WORD_SEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -45426,12 +45426,12 @@ pub static WORD_SEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SC_CHILDREN),
+static WORD_SC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SC_CHILDREN),
     value: None,
 };
 
-static WORD_SC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SCA_NODE),
     None,
     Some(&WORD_SCC_NODE),
@@ -45460,23 +45460,23 @@ static WORD_SC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SCY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCY_CHILDREN),
+static WORD_SCY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hter")],
     values: &[&["scyther"]],
     range: 4..=4,
 };
 
-static WORD_SCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCU_CHILDREN),
+static WORD_SCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bscribe"),
         dictgen::InsensitiveStr::Ascii("bscribed"),
@@ -45528,12 +45528,12 @@ pub static WORD_SCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_SCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCT_CHILDREN),
+static WORD_SCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -45569,12 +45569,12 @@ pub static WORD_SCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_SCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SCR_CHILDREN),
+static WORD_SCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SCR_CHILDREN),
     value: None,
 };
 
-static WORD_SCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SCR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SCRA_NODE),
     None,
     None,
@@ -45603,12 +45603,12 @@ static WORD_SCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SCRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRU_CHILDREN),
+static WORD_SCRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bed"),
         dictgen::InsensitiveStr::Ascii("itny"),
@@ -45628,12 +45628,12 @@ pub static WORD_SCRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SCRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRT_CHILDREN),
+static WORD_SCRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ip"),
         dictgen::InsensitiveStr::Ascii("iped"),
@@ -45644,23 +45644,23 @@ pub static WORD_SCRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_SCRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRR_CHILDREN),
+static WORD_SCRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("en")],
     values: &[&["screen"]],
     range: 2..=2,
 };
 
-static WORD_SCRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRP_CHILDREN),
+static WORD_SCRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("ited"),
@@ -45684,12 +45684,12 @@ pub static WORD_SCRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_SCRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRO_CHILDREN),
+static WORD_SCRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("ipt"),
@@ -45727,12 +45727,12 @@ pub static WORD_SCRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SCRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRI_CHILDREN),
+static WORD_SCRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipt"),
         dictgen::InsensitiveStr::Ascii("ipted"),
@@ -45802,12 +45802,12 @@ pub static WORD_SCRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SCRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRE_CHILDREN),
+static WORD_SCRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eb"),
         dictgen::InsensitiveStr::Ascii("ebs"),
@@ -45849,12 +45849,12 @@ pub static WORD_SCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_SCRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCRA_CHILDREN),
+static WORD_SCRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -45896,23 +45896,23 @@ pub static WORD_SCRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCP_CHILDREN),
+static WORD_SCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eter")],
     values: &[&["scepter"]],
     range: 4..=4,
 };
 
-static WORD_SCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCO_CHILDREN),
+static WORD_SCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ket"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -45970,12 +45970,12 @@ pub static WORD_SCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SCN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCN_CHILDREN),
+static WORD_SCN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adinavia"),
         dictgen::InsensitiveStr::Ascii("adinavian"),
@@ -45991,12 +45991,12 @@ pub static WORD_SCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_SCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCL_CHILDREN),
+static WORD_SCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("ar"),
@@ -46006,12 +46006,12 @@ pub static WORD_SCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCK_CHILDREN),
+static WORD_SCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etch"),
         dictgen::InsensitiveStr::Ascii("etched"),
@@ -46022,12 +46022,12 @@ pub static WORD_SCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCI_CHILDREN),
+static WORD_SCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encers"),
         dictgen::InsensitiveStr::Ascii("encists"),
@@ -46109,12 +46109,12 @@ pub static WORD_SCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_SCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SCH_CHILDREN),
+static WORD_SCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SCH_CHILDREN),
     value: None,
 };
 
-static WORD_SCH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SCH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_SCHC_NODE),
@@ -46143,12 +46143,12 @@ static WORD_SCH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_SCHZ_NODE),
 ];
 
-static WORD_SCHZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHZ_CHILDREN),
+static WORD_SCHZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iophrenia"),
         dictgen::InsensitiveStr::Ascii("iophrenic"),
@@ -46157,12 +46157,12 @@ pub static WORD_SCHZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=9,
 };
 
-static WORD_SCHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHY_CHILDREN),
+static WORD_SCHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHY_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("zophrenia"),
         dictgen::InsensitiveStr::Ascii("zophrenic"),
@@ -46171,23 +46171,23 @@ pub static WORD_SCHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=9,
 };
 
-static WORD_SCHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHU_CHILDREN),
+static WORD_SCHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dule")],
     values: &[&["schedule"]],
     range: 4..=4,
 };
 
-static WORD_SCHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHO_CHILDREN),
+static WORD_SCHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alrs"),
         dictgen::InsensitiveStr::Ascii("alrship"),
@@ -46237,12 +46237,12 @@ pub static WORD_SCHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_SCHM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHM_CHILDREN),
+static WORD_SCHM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ea"),
@@ -46253,12 +46253,12 @@ pub static WORD_SCHM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_SCHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHI_CHILDREN),
+static WORD_SCHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sophrenic"),
         dictgen::InsensitiveStr::Ascii("ziphrenic"),
@@ -46286,12 +46286,12 @@ pub static WORD_SCHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=11,
 };
 
-static WORD_SCHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHE_CHILDREN),
+static WORD_SCHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("dual"),
@@ -46347,12 +46347,12 @@ pub static WORD_SCHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SCHD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHD_CHILDREN),
+static WORD_SCHD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eule"),
         dictgen::InsensitiveStr::Ascii("ule"),
@@ -46374,23 +46374,23 @@ pub static WORD_SCHD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SCHC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCHC_CHILDREN),
+static WORD_SCHC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCHC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCHC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ema")],
     values: &[&["schema"]],
     range: 3..=3,
 };
 
-static WORD_SCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCE_CHILDREN),
+static WORD_SCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anrio"),
         dictgen::InsensitiveStr::Ascii("anrios"),
@@ -46466,12 +46466,12 @@ pub static WORD_SCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_SCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCC_CHILDREN),
+static WORD_SCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("esses"),
@@ -46499,12 +46499,12 @@ pub static WORD_SCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_SCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SCA_CHILDREN),
+static WORD_SCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SCA_CHILDREN),
     value: None,
 };
 
-static WORD_SCA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SCA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -46533,12 +46533,12 @@ static WORD_SCA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SCAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAV_CHILDREN),
+static WORD_SCAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("anged"),
@@ -46556,12 +46556,12 @@ pub static WORD_SCAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_SCAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAT_CHILDREN),
+static WORD_SCAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -46587,12 +46587,12 @@ pub static WORD_SCAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SCAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAR_CHILDREN),
+static WORD_SCAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amento"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -46628,12 +46628,12 @@ pub static WORD_SCAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_SCAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAN_CHILDREN),
+static WORD_SCAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dales"),
         dictgen::InsensitiveStr::Ascii("dalos"),
@@ -46715,12 +46715,12 @@ pub static WORD_SCAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_SCAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAL_CHILDREN),
+static WORD_SCAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("arizaiton"),
@@ -46742,23 +46742,23 @@ pub static WORD_SCAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_SCAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAH_CHILDREN),
+static WORD_SCAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["schar"]],
     range: 1..=1,
 };
 
-static WORD_SCAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAF_CHILDREN),
+static WORD_SCAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("old"),
         dictgen::InsensitiveStr::Ascii("olded"),
@@ -46778,34 +46778,34 @@ pub static WORD_SCAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_SCAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SCAE_CHILDREN),
+static WORD_SCAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SCAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SCAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SCAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pgoat")],
     values: &[&["scapegoat"]],
     range: 5..=5,
 };
 
-static WORD_SB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SB_CHILDREN),
+static WORD_SB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sampling")],
     values: &[&["subsampling"]],
     range: 8..=8,
 };
 
-static WORD_SA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SA_CHILDREN),
+static WORD_SA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SA_CHILDREN),
     value: None,
 };
 
-static WORD_SA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SAA_NODE),
     Some(&WORD_SAB_NODE),
     Some(&WORD_SAC_NODE),
@@ -46834,23 +46834,23 @@ static WORD_SA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAX_CHILDREN),
+static WORD_SAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aphone")],
     values: &[&["saxophone"]],
     range: 6..=6,
 };
 
-static WORD_SAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAW_CHILDREN),
+static WORD_SAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nsea"),
         dictgen::InsensitiveStr::Ascii("nson"),
@@ -46884,12 +46884,12 @@ pub static WORD_SAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_SAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAV_CHILDREN),
+static WORD_SAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAV_CHILDREN),
     value: Some(&["save"]),
 };
 
-pub static WORD_SAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anha"),
         dictgen::InsensitiveStr::Ascii("annh"),
@@ -46925,12 +46925,12 @@ pub static WORD_SAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_SAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAU_CHILDREN),
+static WORD_SAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ght"),
         dictgen::InsensitiveStr::Ascii("tay"),
@@ -46950,12 +46950,12 @@ pub static WORD_SAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_SAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_SAT_CHILDREN),
+static WORD_SAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_SAT_CHILDREN),
     value: None,
 };
 
-static WORD_SAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_SAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_SATA_NODE),
     None,
     None,
@@ -46984,23 +46984,23 @@ static WORD_SAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_SATY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATY_CHILDREN),
+static WORD_SATY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATY_CHILDREN),
     value: Some(&["stay"]),
 };
 
-pub static WORD_SATY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_SATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATU_CHILDREN),
+static WORD_SATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATU_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aday"),
         dictgen::InsensitiveStr::Ascii("adays"),
@@ -47024,12 +47024,12 @@ pub static WORD_SATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_SATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATT_CHILDREN),
+static WORD_SATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elit"),
         dictgen::InsensitiveStr::Ascii("elite"),
@@ -47051,12 +47051,12 @@ pub static WORD_SATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_SATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATS_CHILDREN),
+static WORD_SATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifaction"),
         dictgen::InsensitiveStr::Ascii("ifactory"),
@@ -47078,12 +47078,12 @@ pub static WORD_SATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_SATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATR_CHILDREN),
+static WORD_SATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -47103,12 +47103,12 @@ pub static WORD_SATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_SATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATI_CHILDREN),
+static WORD_SATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -47182,12 +47182,12 @@ pub static WORD_SATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_SATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATE_CHILDREN),
+static WORD_SATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ful"),
         dictgen::InsensitiveStr::Ascii("lite"),
@@ -47217,12 +47217,12 @@ pub static WORD_SATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_SATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SATA_CHILDREN),
+static WORD_SATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndard"),
         dictgen::InsensitiveStr::Ascii("ndards"),
@@ -47238,12 +47238,12 @@ pub static WORD_SATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_SAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAS_CHILDREN),
+static WORD_SAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("auges"),
         dictgen::InsensitiveStr::Ascii("catchewan"),
@@ -47287,12 +47287,12 @@ pub static WORD_SAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_SAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAR_CHILDREN),
+static WORD_SAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cams"),
         dictgen::InsensitiveStr::Ascii("casam"),
@@ -47348,12 +47348,12 @@ pub static WORD_SAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_SAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAP_CHILDREN),
+static WORD_SAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cebar"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -47383,12 +47383,12 @@ pub static WORD_SAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_SAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAN_CHILDREN),
+static WORD_SAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aty"),
         dictgen::InsensitiveStr::Ascii("bdox"),
@@ -47504,12 +47504,12 @@ pub static WORD_SAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_SAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAM_CHILDREN),
+static WORD_SAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aphore"),
         dictgen::InsensitiveStr::Ascii("aphores"),
@@ -47557,12 +47557,12 @@ pub static WORD_SAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_SAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAL_CHILDREN),
+static WORD_SAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aires"),
         dictgen::InsensitiveStr::Ascii("aris"),
@@ -47592,45 +47592,45 @@ pub static WORD_SAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_SAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAK_CHILDREN),
+static WORD_SAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("satchewan")],
     values: &[&["saskatchewan"]],
     range: 9..=9,
 };
 
-static WORD_SAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAI_CHILDREN),
+static WORD_SAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["says"]],
     range: 1..=1,
 };
 
-static WORD_SAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAH_CHILDREN),
+static WORD_SAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("re")],
     values: &[&["share"]],
     range: 2..=2,
 };
 
-static WORD_SAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAG_CHILDREN),
+static WORD_SAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gital"),
         dictgen::InsensitiveStr::Ascii("ital"),
@@ -47640,12 +47640,12 @@ pub static WORD_SAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_SAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAF_CHILDREN),
+static WORD_SAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eguared"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -47673,12 +47673,12 @@ pub static WORD_SAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_SAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAE_CHILDREN),
+static WORD_SAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("rching"),
@@ -47687,12 +47687,12 @@ pub static WORD_SAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_SAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAD_CHILDREN),
+static WORD_SAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dends"),
         dictgen::InsensitiveStr::Ascii("denes"),
@@ -47720,12 +47720,12 @@ pub static WORD_SAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_SAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAC_CHILDREN),
+static WORD_SAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alar"),
         dictgen::InsensitiveStr::Ascii("alars"),
@@ -47821,12 +47821,12 @@ pub static WORD_SAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_SAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAB_CHILDREN),
+static WORD_SAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atage"),
         dictgen::InsensitiveStr::Ascii("atosh"),
@@ -47848,12 +47848,12 @@ pub static WORD_SAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_SAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_SAA_CHILDREN),
+static WORD_SAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_SAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_SAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_SAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("me"),
         dictgen::InsensitiveStr::Ascii("ndbox"),
@@ -47862,12 +47862,12 @@ pub static WORD_SAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_R_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_R_CHILDREN),
+static WORD_R_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_R_CHILDREN),
     value: None,
 };
 
-static WORD_R_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_R_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RA_NODE),
     None,
     Some(&WORD_RC_NODE),
@@ -47896,12 +47896,12 @@ static WORD_R_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RY_CHILDREN),
+static WORD_RY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enolds"),
         dictgen::InsensitiveStr::Ascii("ou"),
@@ -47929,23 +47929,23 @@ pub static WORD_RY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_RW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RW_CHILDREN),
+static WORD_RW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RW_CHILDREN),
     value: None,
 };
 
-pub static WORD_RW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ite")],
     values: &[&["write"]],
     range: 3..=3,
 };
 
-static WORD_RU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RU_CHILDREN),
+static WORD_RU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("barb"),
         dictgen::InsensitiveStr::Ascii("cuperate"),
@@ -48041,12 +48041,12 @@ pub static WORD_RU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_RT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RT_CHILDREN),
+static WORD_RT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -48066,12 +48066,12 @@ pub static WORD_RT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_RS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RS_CHILDREN),
+static WORD_RS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eolution"),
         dictgen::InsensitiveStr::Ascii("icv"),
@@ -48093,12 +48093,12 @@ pub static WORD_RS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_RR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RR_CHILDREN),
+static WORD_RR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anslation"),
         dictgen::InsensitiveStr::Ascii("anslations"),
@@ -48124,12 +48124,12 @@ pub static WORD_RR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_RQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RQ_CHILDREN),
+static WORD_RQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euest"),
         dictgen::InsensitiveStr::Ascii("euested"),
@@ -48163,23 +48163,23 @@ pub static WORD_RQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_RP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RP_CHILDREN),
+static WORD_RP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lace")],
     values: &[&["replace"]],
     range: 4..=4,
 };
 
-static WORD_RO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RO_CHILDREN),
+static WORD_RO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RO_CHILDREN),
     value: None,
 };
 
-static WORD_RO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ROA_NODE),
     Some(&WORD_ROB_NODE),
     Some(&WORD_ROC_NODE),
@@ -48208,12 +48208,12 @@ static WORD_RO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ROY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROY_CHILDREN),
+static WORD_ROY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alites"),
         dictgen::InsensitiveStr::Ascii("laties"),
@@ -48222,12 +48222,12 @@ pub static WORD_ROY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=6,
 };
 
-static WORD_ROV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROV_CHILDREN),
+static WORD_ROV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ide"),
         dictgen::InsensitiveStr::Ascii("ided"),
@@ -48245,12 +48245,12 @@ pub static WORD_ROV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROU_CHILDREN),
+static WORD_ROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("ghtly"),
@@ -48318,12 +48318,12 @@ pub static WORD_ROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ROT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROT_CHILDREN),
+static WORD_ROT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aion"),
         dictgen::InsensitiveStr::Ascii("aions"),
@@ -48363,12 +48363,12 @@ pub static WORD_ROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ROS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROS_CHILDREN),
+static WORD_ROS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ettta"),
         dictgen::InsensitiveStr::Ascii("ponse"),
@@ -48379,23 +48379,23 @@ pub static WORD_ROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_ROR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROR_CHILDREN),
+static WORD_ROR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ated")],
     values: &[&["rotated"]],
     range: 4..=4,
 };
 
-static WORD_ROP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROP_CHILDREN),
+static WORD_ROP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eat"),
         dictgen::InsensitiveStr::Ascii("ository"),
@@ -48404,12 +48404,12 @@ pub static WORD_ROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_ROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROO_CHILDREN),
+static WORD_ROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mate"),
         dictgen::InsensitiveStr::Ascii("mates"),
@@ -48418,12 +48418,12 @@ pub static WORD_ROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_RON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RON_CHILDREN),
+static WORD_RON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RON_CHILDREN),
     value: None,
 };
 
-pub static WORD_RON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dayvoo"),
         dictgen::InsensitiveStr::Ascii("dayvooed"),
@@ -48447,12 +48447,12 @@ pub static WORD_RON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_ROM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROM_CHILDREN),
+static WORD_ROM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aanin"),
         dictgen::InsensitiveStr::Ascii("aina"),
@@ -48498,12 +48498,12 @@ pub static WORD_ROM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ROL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROL_CHILDREN),
+static WORD_ROL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("epaly"),
         dictgen::InsensitiveStr::Ascii("epalying"),
@@ -48537,12 +48537,12 @@ pub static WORD_ROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ROI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROI_CHILDREN),
+static WORD_ROI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gin"),
         dictgen::InsensitiveStr::Ascii("ginal"),
@@ -48564,12 +48564,12 @@ pub static WORD_ROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ROG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROG_CHILDREN),
+static WORD_ROG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anism"),
         dictgen::InsensitiveStr::Ascii("anisms"),
@@ -48579,12 +48579,12 @@ pub static WORD_ROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ROE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROE_CHILDREN),
+static WORD_ROE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lplay"),
         dictgen::InsensitiveStr::Ascii("ls"),
@@ -48594,12 +48594,12 @@ pub static WORD_ROE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ROD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROD_CHILDREN),
+static WORD_ROD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uce"),
         dictgen::InsensitiveStr::Ascii("uceer"),
@@ -48608,12 +48608,12 @@ pub static WORD_ROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROC_CHILDREN),
+static WORD_ROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("kerfeller"),
@@ -48639,12 +48639,12 @@ pub static WORD_ROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROB_CHILDREN),
+static WORD_ROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("berts"),
         dictgen::InsensitiveStr::Ascii("berys"),
@@ -48672,12 +48672,12 @@ pub static WORD_ROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_ROA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ROA_CHILDREN),
+static WORD_ROA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ROA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ROA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chers"),
         dictgen::InsensitiveStr::Ascii("hces"),
@@ -48701,12 +48701,12 @@ pub static WORD_ROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_RN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RN_CHILDREN),
+static WORD_RN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ger"),
@@ -48716,12 +48716,12 @@ pub static WORD_RN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_RM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RM_CHILDREN),
+static WORD_RM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eote"),
         dictgen::InsensitiveStr::Ascii("eove"),
@@ -48743,12 +48743,12 @@ pub static WORD_RM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_RL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RL_CHILDREN),
+static WORD_RL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -48758,12 +48758,12 @@ pub static WORD_RL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_RI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RI_CHILDREN),
+static WORD_RI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RI_CHILDREN),
     value: None,
 };
 
-static WORD_RI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RIA_NODE),
     None,
     Some(&WORD_RIC_NODE),
@@ -48792,23 +48792,23 @@ static WORD_RI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_RIZ_NODE),
 ];
 
-static WORD_RIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIZ_CHILDREN),
+static WORD_RIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["rises"]],
     range: 2..=2,
 };
 
-static WORD_RIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIV_CHILDREN),
+static WORD_RIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alrly"),
         dictgen::InsensitiveStr::Ascii("arlies"),
@@ -48830,12 +48830,12 @@ pub static WORD_RIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_RIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIT_CHILDREN),
+static WORD_RIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("alian"),
@@ -48869,12 +48869,12 @@ pub static WORD_RIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_RIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIS_CHILDREN),
+static WORD_RIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("kay"),
@@ -48894,12 +48894,12 @@ pub static WORD_RIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_RIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIN_CHILDREN),
+static WORD_RIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gotne"),
         dictgen::InsensitiveStr::Ascii("inging"),
@@ -48917,12 +48917,12 @@ pub static WORD_RIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_RIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIM_CHILDREN),
+static WORD_RIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aniss"),
         dictgen::InsensitiveStr::Ascii("anissed"),
@@ -48960,23 +48960,23 @@ pub static WORD_RIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_RIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIL_CHILDREN),
+static WORD_RIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("varies")],
     values: &[&["rivalries"]],
     range: 6..=6,
 };
 
-static WORD_RIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIG_CHILDREN),
+static WORD_RIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -49036,12 +49036,12 @@ pub static WORD_RIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_RIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIE_CHILDREN),
+static WORD_RIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndeer"),
         dictgen::InsensitiveStr::Ascii("ndeers"),
@@ -49059,12 +49059,12 @@ pub static WORD_RIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_RID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RID_CHILDREN),
+static WORD_RID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RID_CHILDREN),
     value: None,
 };
 
-pub static WORD_RID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icilous"),
         dictgen::InsensitiveStr::Ascii("icilously"),
@@ -49110,12 +49110,12 @@ pub static WORD_RID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=12,
 };
 
-static WORD_RIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIC_CHILDREN),
+static WORD_RIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hochet"),
         dictgen::InsensitiveStr::Ascii("hochets"),
@@ -49137,23 +49137,23 @@ pub static WORD_RIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_RIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RIA_CHILDREN),
+static WORD_RIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ders")],
     values: &[&["raiders"]],
     range: 4..=4,
 };
 
-static WORD_RH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RH_CHILDREN),
+static WORD_RH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aposdy"),
         dictgen::InsensitiveStr::Ascii("apsodomy"),
@@ -49197,12 +49197,12 @@ pub static WORD_RH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_RG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RG_CHILDREN),
+static WORD_RG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eards"),
         dictgen::InsensitiveStr::Ascii("ister"),
@@ -49212,12 +49212,12 @@ pub static WORD_RG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_RF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RF_CHILDREN),
+static WORD_RF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erence"),
         dictgen::InsensitiveStr::Ascii("erences"),
@@ -49227,12 +49227,12 @@ pub static WORD_RF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_RE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RE_CHILDREN),
+static WORD_RE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RE_CHILDREN),
     value: None,
 };
 
-static WORD_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REA_NODE),
     Some(&WORD_REB_NODE),
     Some(&WORD_REC_NODE),
@@ -49261,23 +49261,23 @@ static WORD_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_REZ_NODE),
 ];
 
-static WORD_REZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REZ_CHILDREN),
+static WORD_REZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("urrection")],
     values: &[&["resurrection"]],
     range: 9..=9,
 };
 
-static WORD_REY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REY_CHILDREN),
+static WORD_REY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REY_CHILDREN),
     value: None,
 };
 
-pub static WORD_REY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nlods"),
         dictgen::InsensitiveStr::Ascii("nols"),
@@ -49287,12 +49287,12 @@ pub static WORD_REY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_REW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REW_CHILDREN),
+static WORD_REW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REW_CHILDREN),
     value: None,
 };
 
-pub static WORD_REW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achted"),
         dictgen::InsensitiveStr::Ascii("arching"),
@@ -49358,12 +49358,12 @@ pub static WORD_REW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_REV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REV_CHILDREN),
+static WORD_REV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REV_CHILDREN),
     value: None,
 };
 
-static WORD_REV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REVA_NODE),
     None,
     None,
@@ -49392,12 +49392,12 @@ static WORD_REV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVS_CHILDREN),
+static WORD_REVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erse"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -49407,12 +49407,12 @@ pub static WORD_REVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVR_CHILDREN),
+static WORD_REVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ese"),
         dictgen::InsensitiveStr::Ascii("ieve"),
@@ -49432,12 +49432,12 @@ pub static WORD_REVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVO_CHILDREN),
+static WORD_REVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("kation"),
@@ -49523,12 +49523,12 @@ pub static WORD_REVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_REVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVL_CHILDREN),
+static WORD_REVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alidation"),
         dictgen::InsensitiveStr::Ascii("over"),
@@ -49538,12 +49538,12 @@ pub static WORD_REVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_REVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVI_CHILDREN),
+static WORD_REVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ere"),
         dictgen::InsensitiveStr::Ascii("ewd"),
@@ -49593,12 +49593,12 @@ pub static WORD_REVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVE_CHILDREN),
+static WORD_REVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ald"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -49704,12 +49704,12 @@ pub static WORD_REVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_REVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REVA_CHILDREN),
+static WORD_REVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ildating"),
         dictgen::InsensitiveStr::Ascii("luated"),
@@ -49718,12 +49718,12 @@ pub static WORD_REVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_REU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REU_CHILDREN),
+static WORD_REU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asble"),
         dictgen::InsensitiveStr::Ascii("dce"),
@@ -49839,12 +49839,12 @@ pub static WORD_REU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_RET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RET_CHILDREN),
+static WORD_RET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RET_CHILDREN),
     value: None,
 };
 
-static WORD_RET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RET_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RETA_NODE),
     None,
     Some(&WORD_RETC_NODE),
@@ -49873,12 +49873,12 @@ static WORD_RET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RETY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETY_CHILDREN),
+static WORD_RETY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETY_CHILDREN),
     value: Some(&["retry"]),
 };
 
-pub static WORD_RETY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rable"),
         dictgen::InsensitiveStr::Ascii("ring"),
@@ -49887,12 +49887,12 @@ pub static WORD_RETY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_RETU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETU_CHILDREN),
+static WORD_RETU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("end"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -49966,12 +49966,12 @@ pub static WORD_RETU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RETS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETS_CHILDREN),
+static WORD_RETS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("art"),
         dictgen::InsensitiveStr::Ascii("arts"),
@@ -49980,12 +49980,12 @@ pub static WORD_RETS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_RETR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RETR_CHILDREN),
+static WORD_RETR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RETR_CHILDREN),
     value: None,
 };
 
-static WORD_RETR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RETR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RETRA_NODE),
     None,
     None,
@@ -50014,12 +50014,12 @@ static WORD_RETR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RETRV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRV_CHILDREN),
+static WORD_RETRV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ieve"),
         dictgen::InsensitiveStr::Ascii("ieved"),
@@ -50037,12 +50037,12 @@ pub static WORD_RETRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_RETRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRU_CHILDREN),
+static WORD_RETRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bution"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -50062,12 +50062,12 @@ pub static WORD_RETRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RETRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRO_CHILDREN),
+static WORD_RETRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("activelly"),
         dictgen::InsensitiveStr::Ascii("activily"),
@@ -50091,12 +50091,12 @@ pub static WORD_RETRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_RETRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRN_CHILDREN),
+static WORD_RETRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRN_CHILDREN),
     value: Some(&["return"]),
 };
 
-pub static WORD_RETRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -50105,12 +50105,12 @@ pub static WORD_RETRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_RETRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRI_CHILDREN),
+static WORD_RETRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bucion"),
         dictgen::InsensitiveStr::Ascii("buito"),
@@ -50158,12 +50158,12 @@ pub static WORD_RETRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_RETRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRE_CHILDREN),
+static WORD_RETRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aving"),
         dictgen::InsensitiveStr::Ascii("bution"),
@@ -50215,12 +50215,12 @@ pub static WORD_RETRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RETRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETRA_CHILDREN),
+static WORD_RETRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nser"),
         dictgen::InsensitiveStr::Ascii("nsferd"),
@@ -50244,12 +50244,12 @@ pub static WORD_RETRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_RETQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETQ_CHILDREN),
+static WORD_RETQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uirement"),
         dictgen::InsensitiveStr::Ascii("uirements"),
@@ -50269,23 +50269,23 @@ pub static WORD_RETQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_RETP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETP_CHILDREN),
+static WORD_RETP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("resenting")],
     values: &[&["representing"]],
     range: 9..=9,
 };
 
-static WORD_RETO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETO_CHILDREN),
+static WORD_RETO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ractively"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -50309,12 +50309,12 @@ pub static WORD_RETO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RETI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETI_CHILDREN),
+static WORD_RETI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erment"),
         dictgen::InsensitiveStr::Ascii("eval"),
@@ -50362,12 +50362,12 @@ pub static WORD_RETI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RETH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETH_CHILDREN),
+static WORD_RETH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("oric"),
@@ -50377,12 +50377,12 @@ pub static WORD_RETH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RETE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETE_CHILDREN),
+static WORD_RETE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("river"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -50396,12 +50396,12 @@ pub static WORD_RETE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RETC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETC_CHILDREN),
+static WORD_RETC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ieve"),
         dictgen::InsensitiveStr::Ascii("ieved"),
@@ -50419,12 +50419,12 @@ pub static WORD_RETC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_RETA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RETA_CHILDREN),
+static WORD_RETA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RETA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RETA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RETA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilate"),
         dictgen::InsensitiveStr::Ascii("ilation"),
@@ -50476,12 +50476,12 @@ pub static WORD_RETA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RES_CHILDREN),
+static WORD_RES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RES_CHILDREN),
     value: None,
 };
 
-static WORD_RES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RESA_NODE),
     None,
     Some(&WORD_RESC_NODE),
@@ -50510,34 +50510,34 @@ static WORD_RES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESY_CHILDREN),
+static WORD_RESY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cn")],
     values: &[&["resync"]],
     range: 2..=2,
 };
 
-static WORD_RESV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESV_CHILDREN),
+static WORD_RESV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olved")],
     values: &[&["resolved"]],
     range: 5..=5,
 };
 
-static WORD_RESU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESU_CHILDREN),
+static WORD_RESU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -50649,12 +50649,12 @@ pub static WORD_RESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_REST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REST_CHILDREN),
+static WORD_REST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REST_CHILDREN),
     value: None,
 };
 
-static WORD_REST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RESTA_NODE),
     None,
     None,
@@ -50683,12 +50683,12 @@ static WORD_REST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTU_CHILDREN),
+static WORD_RESTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arant"),
         dictgen::InsensitiveStr::Ascii("arants"),
@@ -50724,12 +50724,12 @@ pub static WORD_RESTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_RESTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTR_CHILDREN),
+static WORD_RESTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aind"),
         dictgen::InsensitiveStr::Ascii("aing"),
@@ -50829,12 +50829,12 @@ pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RESTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTO_CHILDREN),
+static WORD_RESTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("iring"),
@@ -50870,12 +50870,12 @@ pub static WORD_RESTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_RESTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTI_CHILDREN),
+static WORD_RESTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cted"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -50909,12 +50909,12 @@ pub static WORD_RESTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_RESTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTE_CHILDREN),
+static WORD_RESTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("raunt"),
         dictgen::InsensitiveStr::Ascii("raunts"),
@@ -50930,12 +50930,12 @@ pub static WORD_RESTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RESTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESTA_CHILDREN),
+static WORD_RESTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nti"),
         dictgen::InsensitiveStr::Ascii("rant"),
@@ -50987,12 +50987,12 @@ pub static WORD_RESTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_RESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESS_CHILDREN),
+static WORD_RESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apee"),
         dictgen::InsensitiveStr::Ascii("emblance"),
@@ -51064,12 +51064,12 @@ pub static WORD_RESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RESR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESR_CHILDREN),
+static WORD_RESR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ouce"),
         dictgen::InsensitiveStr::Ascii("ouced"),
@@ -51087,23 +51087,23 @@ pub static WORD_RESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_RESQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESQ_CHILDREN),
+static WORD_RESQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uest")],
     values: &[&["request"]],
     range: 4..=4,
 };
 
-static WORD_RESP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RESP_CHILDREN),
+static WORD_RESP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RESP_CHILDREN),
     value: None,
 };
 
-static WORD_RESP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RESP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RESPA_NODE),
     None,
     None,
@@ -51132,12 +51132,12 @@ static WORD_RESP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESPW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPW_CHILDREN),
+static WORD_RESPW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPW_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("aned"),
@@ -51148,23 +51148,23 @@ pub static WORD_RESPW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RESPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPS_CHILDREN),
+static WORD_RESPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ectively")],
     values: &[&["respectively"]],
     range: 8..=8,
 };
 
-static WORD_RESPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPR_CHILDREN),
+static WORD_RESPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esent"),
         dictgen::InsensitiveStr::Ascii("esentation"),
@@ -51188,12 +51188,12 @@ pub static WORD_RESPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=12,
 };
 
-static WORD_RESPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPP_CHILDREN),
+static WORD_RESPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onse"),
         dictgen::InsensitiveStr::Ascii("onses"),
@@ -51202,12 +51202,12 @@ pub static WORD_RESPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_RESPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RESPO_CHILDREN),
+static WORD_RESPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RESPO_CHILDREN),
     value: None,
 };
 
-static WORD_RESPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RESPO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -51236,12 +51236,12 @@ static WORD_RESPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESPOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOT_CHILDREN),
+static WORD_RESPOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -51250,12 +51250,12 @@ pub static WORD_RESPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_RESPOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOS_CHILDREN),
+static WORD_RESPOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -51285,23 +51285,23 @@ pub static WORD_RESPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_RESPOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOR_CHILDREN),
+static WORD_RESPOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atory")],
     values: &[&["respiratory"]],
     range: 5..=5,
 };
 
-static WORD_RESPON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RESPON_CHILDREN),
+static WORD_RESPON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RESPON_CHILDREN),
     value: None,
 };
 
-static WORD_RESPON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RESPON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_RESPONC_NODE),
@@ -51330,12 +51330,12 @@ static WORD_RESPON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESPONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONS_CHILDREN),
+static WORD_RESPONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONS_CHILDREN),
     value: Some(&["response", "respond"]),
 };
 
-pub static WORD_RESPONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abile"),
         dictgen::InsensitiveStr::Ascii("abilities"),
@@ -51423,23 +51423,23 @@ pub static WORD_RESPONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=10,
 };
 
-static WORD_RESPONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONN_CHILDREN),
+static WORD_RESPONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sibilty")],
     values: &[&["responsibility"]],
     range: 7..=7,
 };
 
-static WORD_RESPONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONI_CHILDREN),
+static WORD_RESPONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilities"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -51461,12 +51461,12 @@ pub static WORD_RESPONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=9,
 };
 
-static WORD_RESPONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONE_CHILDREN),
+static WORD_RESPONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONE_CHILDREN),
     value: Some(&["response", "respond"]),
 };
 
-pub static WORD_RESPONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -51475,12 +51475,12 @@ pub static WORD_RESPONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=1,
 };
 
-static WORD_RESPOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOND_CHILDREN),
+static WORD_RESPOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -51500,12 +51500,12 @@ pub static WORD_RESPOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=4,
 };
 
-static WORD_RESPONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPONC_CHILDREN),
+static WORD_RESPONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPONC_CHILDREN),
     value: Some(&["response", "respond"]),
 };
 
-pub static WORD_RESPONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -51527,23 +51527,23 @@ pub static WORD_RESPONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_RESPOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPOD_CHILDREN),
+static WORD_RESPOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uce")],
     values: &[&["reproduce"]],
     range: 3..=3,
 };
 
-static WORD_RESPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPN_CHILDREN),
+static WORD_RESPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -51552,12 +51552,12 @@ pub static WORD_RESPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_RESPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPI_CHILDREN),
+static WORD_RESPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ratiory"),
         dictgen::InsensitiveStr::Ascii("ratoy"),
@@ -51573,12 +51573,12 @@ pub static WORD_RESPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_RESPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPE_CHILDREN),
+static WORD_RESPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("catble"),
         dictgen::InsensitiveStr::Ascii("citve"),
@@ -51642,23 +51642,23 @@ pub static WORD_RESPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RESPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESPA_CHILDREN),
+static WORD_RESPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("wining")],
     values: &[&["respawning"]],
     range: 6..=6,
 };
 
-static WORD_RESO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RESO_CHILDREN),
+static WORD_RESO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RESO_CHILDREN),
     value: None,
 };
 
-static WORD_RESO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RESO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -51687,12 +51687,12 @@ static WORD_RESO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RESOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOV_CHILDREN),
+static WORD_RESOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("lable"),
@@ -51716,12 +51716,12 @@ pub static WORD_RESOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RESOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOU_CHILDREN),
+static WORD_RESOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -51771,12 +51771,12 @@ pub static WORD_RESOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RESOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOT_CHILDREN),
+static WORD_RESOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ration"),
         dictgen::InsensitiveStr::Ascii("rations"),
@@ -51802,12 +51802,12 @@ pub static WORD_RESOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_RESOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOR_CHILDREN),
+static WORD_RESOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -51839,12 +51839,12 @@ pub static WORD_RESOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RESOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOP_CHILDREN),
+static WORD_RESOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nse"),
         dictgen::InsensitiveStr::Ascii("nses"),
@@ -51854,12 +51854,12 @@ pub static WORD_RESOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_RESOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOO_CHILDREN),
+static WORD_RESOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("urce"),
         dictgen::InsensitiveStr::Ascii("urced"),
@@ -51875,12 +51875,12 @@ pub static WORD_RESOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_RESON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESON_CHILDREN),
+static WORD_RESON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESON_CHILDREN),
     value: Some(&["reason"]),
 };
 
-pub static WORD_RESON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abelt"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -51902,12 +51902,12 @@ pub static WORD_RESON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RESOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOL_CHILDREN),
+static WORD_RESOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -51961,12 +51961,12 @@ pub static WORD_RESOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_RESOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOI_CHILDREN),
+static WORD_RESOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("urce"),
         dictgen::InsensitiveStr::Ascii("urced"),
@@ -51982,12 +51982,12 @@ pub static WORD_RESOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_RESOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESOE_CHILDREN),
+static WORD_RESOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -51996,12 +51996,12 @@ pub static WORD_RESOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RESM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESM_CHILDREN),
+static WORD_RESM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eble"),
         dictgen::InsensitiveStr::Ascii("ebles"),
@@ -52010,12 +52010,12 @@ pub static WORD_RESM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_RESL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESL_CHILDREN),
+static WORD_RESL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ection"),
         dictgen::InsensitiveStr::Ascii("ove"),
@@ -52039,12 +52039,12 @@ pub static WORD_RESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RESI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESI_CHILDREN),
+static WORD_RESI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dencial"),
         dictgen::InsensitiveStr::Ascii("dentail"),
@@ -52144,23 +52144,23 @@ pub static WORD_RESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_RESH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESH_CHILDREN),
+static WORD_RESH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("edule")],
     values: &[&["reschedule"]],
     range: 5..=5,
 };
 
-static WORD_RESG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESG_CHILDREN),
+static WORD_RESG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ination"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -52176,12 +52176,12 @@ pub static WORD_RESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_RESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESE_CHILDREN),
+static WORD_RESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -52305,12 +52305,12 @@ pub static WORD_RESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RESC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESC_CHILDREN),
+static WORD_RESC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aned"),
         dictgen::InsensitiveStr::Ascii("edule"),
@@ -52344,12 +52344,12 @@ pub static WORD_RESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RESA_CHILDREN),
+static WORD_RESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erch"),
         dictgen::InsensitiveStr::Ascii("ons"),
@@ -52375,12 +52375,12 @@ pub static WORD_RESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RER_CHILDREN),
+static WORD_RER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RER_CHILDREN),
     value: None,
 };
 
-pub static WORD_RER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eated"),
         dictgen::InsensitiveStr::Ascii("egisteration"),
@@ -52420,12 +52420,12 @@ pub static WORD_RER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_REQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REQ_CHILDREN),
+static WORD_REQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REQ_CHILDREN),
     value: None,
 };
 
-static WORD_REQ_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REQ_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -52454,12 +52454,12 @@ static WORD_REQ_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REQU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REQU_CHILDREN),
+static WORD_REQU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REQU_CHILDREN),
     value: None,
 };
 
-static WORD_REQU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REQU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -52488,12 +52488,12 @@ static WORD_REQU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REQUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQUS_CHILDREN),
+static WORD_REQUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ite"),
@@ -52515,12 +52515,12 @@ pub static WORD_REQUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_REQUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQUR_CHILDREN),
+static WORD_REQUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -52566,12 +52566,12 @@ pub static WORD_REQUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REQUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQUI_CHILDREN),
+static WORD_REQUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ements"),
@@ -52651,12 +52651,12 @@ pub static WORD_REQUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REQUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQUE_CHILDREN),
+static WORD_REQUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("im"),
@@ -52720,12 +52720,12 @@ pub static WORD_REQUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_REQR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQR_CHILDREN),
+static WORD_REQR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ite"),
         dictgen::InsensitiveStr::Ascii("ites"),
@@ -52735,23 +52735,23 @@ pub static WORD_REQR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_REQQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQQ_CHILDREN),
+static WORD_REQQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uests")],
     values: &[&["requests"]],
     range: 5..=5,
 };
 
-static WORD_REQI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQI_CHILDREN),
+static WORD_REQI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -52793,12 +52793,12 @@ pub static WORD_REQI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REQE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REQE_CHILDREN),
+static WORD_REQE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REQE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REQE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REQE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("st"),
         dictgen::InsensitiveStr::Ascii("sted"),
@@ -52822,12 +52822,12 @@ pub static WORD_REQE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_REP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REP_CHILDREN),
+static WORD_REP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REP_CHILDREN),
     value: None,
 };
 
-static WORD_REP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPA_NODE),
     Some(&WORD_REPB_NODE),
     None,
@@ -52856,12 +52856,12 @@ static WORD_REP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPU_CHILDREN),
+static WORD_REPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bic"),
         dictgen::InsensitiveStr::Ascii("bican"),
@@ -52931,12 +52931,12 @@ pub static WORD_REPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPT_CHILDREN),
+static WORD_REPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iel"),
         dictgen::InsensitiveStr::Ascii("ils"),
@@ -52954,12 +52954,12 @@ pub static WORD_REPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPS_CHILDREN),
+static WORD_REPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("awn"),
         dictgen::InsensitiveStr::Ascii("ectable"),
@@ -53017,12 +53017,12 @@ pub static WORD_REPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_REPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPR_CHILDREN),
+static WORD_REPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPR_CHILDREN),
     value: None,
 };
 
-static WORD_REPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPRA_NODE),
     None,
     None,
@@ -53051,34 +53051,34 @@ static WORD_REPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRU_CHILDREN),
+static WORD_REPRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cible")],
     values: &[&["reproducible"]],
     range: 5..=5,
 };
 
-static WORD_REPRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRT_CHILDREN),
+static WORD_REPRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oire")],
     values: &[&["repertoire"]],
     range: 4..=4,
 };
 
-static WORD_REPRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRS_CHILDREN),
+static WORD_REPRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -53098,12 +53098,12 @@ pub static WORD_REPRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_REPRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRO_CHILDREN),
+static WORD_REPRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciblbe"),
         dictgen::InsensitiveStr::Ascii("cible"),
@@ -53187,12 +53187,12 @@ pub static WORD_REPRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_REPRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRI_CHILDREN),
+static WORD_REPRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cussions"),
         dictgen::InsensitiveStr::Ascii("hensible"),
@@ -53201,23 +53201,23 @@ pub static WORD_REPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=8,
 };
 
-static WORD_REPRH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRH_CHILDREN),
+static WORD_REPRH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRH_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ase")],
     values: &[&["rephrase"]],
     range: 3..=3,
 };
 
-static WORD_REPRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPRE_CHILDREN),
+static WORD_REPRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPRE_CHILDREN),
     value: None,
 };
 
-static WORD_REPRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_REPREC_NODE),
@@ -53246,23 +53246,23 @@ static WORD_REPRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPREZ_NODE),
 ];
 
-static WORD_REPREZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREZ_CHILDREN),
+static WORD_REPREZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("entative")],
     values: &[&["representative"]],
     range: 8..=8,
 };
 
-static WORD_REPRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPRES_CHILDREN),
+static WORD_REPRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPRES_CHILDREN),
     value: None,
 };
 
-static WORD_REPRES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPRES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPRESA_NODE),
     None,
     None,
@@ -53291,12 +53291,12 @@ static WORD_REPRES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPRESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRESS_CHILDREN),
+static WORD_REPRESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -53322,12 +53322,12 @@ pub static WORD_REPRESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_REPRESN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRESN_CHILDREN),
+static WORD_REPRESN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRESN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRESN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etated"),
@@ -53361,12 +53361,12 @@ pub static WORD_REPRESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_REPRESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRESE_CHILDREN),
+static WORD_REPRESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("natation"),
         dictgen::InsensitiveStr::Ascii("natational"),
@@ -53488,12 +53488,12 @@ pub static WORD_REPRESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=10,
 };
 
-static WORD_REPRESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRESA_CHILDREN),
+static WORD_REPRESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("ntation"),
@@ -53519,23 +53519,23 @@ pub static WORD_REPRESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=9,
 };
 
-static WORD_REPREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREP_CHILDREN),
+static WORD_REPREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("resents")],
     values: &[&["represents"]],
     range: 7..=7,
 };
 
-static WORD_REPREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREN_CHILDREN),
+static WORD_REPREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sent"),
         dictgen::InsensitiveStr::Ascii("sentation"),
@@ -53561,12 +53561,12 @@ pub static WORD_REPREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_REPREH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREH_CHILDREN),
+static WORD_REPREH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREH_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enisble"),
         dictgen::InsensitiveStr::Ascii("ensable"),
@@ -53576,12 +53576,12 @@ pub static WORD_REPREH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=7,
 };
 
-static WORD_REPREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREE_CHILDREN),
+static WORD_REPREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("snt"),
         dictgen::InsensitiveStr::Ascii("snted"),
@@ -53591,12 +53591,12 @@ pub static WORD_REPREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_REPREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPREC_CHILDREN),
+static WORD_REPREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ussion"),
         dictgen::InsensitiveStr::Ascii("ussions"),
@@ -53605,12 +53605,12 @@ pub static WORD_REPREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=7,
 };
 
-static WORD_REPRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPRA_CHILDREN),
+static WORD_REPRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esentation"),
         dictgen::InsensitiveStr::Ascii("esentational"),
@@ -53626,12 +53626,12 @@ pub static WORD_REPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_REPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPP_CHILDREN),
+static WORD_REPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ository"),
@@ -53640,12 +53640,12 @@ pub static WORD_REPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_REPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPO_CHILDREN),
+static WORD_REPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("erter"),
@@ -53779,12 +53779,12 @@ pub static WORD_REPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_REPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPL_CHILDREN),
+static WORD_REPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPL_CHILDREN),
     value: None,
 };
 
-static WORD_REPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPLA_NODE),
     None,
     Some(&WORD_REPLC_NODE),
@@ -53813,12 +53813,12 @@ static WORD_REPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLY_CHILDREN),
+static WORD_REPLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ign"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -53827,12 +53827,12 @@ pub static WORD_REPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_REPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLU_CHILDREN),
+static WORD_REPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bic"),
         dictgen::InsensitiveStr::Ascii("sive"),
@@ -53841,23 +53841,23 @@ pub static WORD_REPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REPLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLO_CHILDREN),
+static WORD_REPLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ying")],
     values: &[&["redeploying"]],
     range: 4..=4,
 };
 
-static WORD_REPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLI_CHILDREN),
+static WORD_REPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cae"),
         dictgen::InsensitiveStr::Ascii("caes"),
@@ -53893,12 +53893,12 @@ pub static WORD_REPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REPLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLE_CHILDREN),
+static WORD_REPLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acable"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -53920,12 +53920,12 @@ pub static WORD_REPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_REPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLC_CHILDREN),
+static WORD_REPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -53943,12 +53943,12 @@ pub static WORD_REPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPLA_CHILDREN),
+static WORD_REPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ca"),
         dictgen::InsensitiveStr::Ascii("cability"),
@@ -54050,12 +54050,12 @@ pub static WORD_REPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPI_CHILDREN),
+static WORD_REPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("lcas"),
@@ -54081,12 +54081,12 @@ pub static WORD_REPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_REPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPH_CHILDREN),
+static WORD_REPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arse"),
         dictgen::InsensitiveStr::Ascii("rasse"),
@@ -54095,12 +54095,12 @@ pub static WORD_REPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_REPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REPE_CHILDREN),
+static WORD_REPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REPE_CHILDREN),
     value: None,
 };
 
-static WORD_REPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REPEA_NODE),
     None,
     Some(&WORD_REPEC_NODE),
@@ -54129,12 +54129,12 @@ static WORD_REPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPET_CHILDREN),
+static WORD_REPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPET_CHILDREN),
     value: Some(&["repeat"]),
 };
 
-pub static WORD_REPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -54174,12 +54174,12 @@ pub static WORD_REPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_REPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPES_CHILDREN),
+static WORD_REPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -54199,12 +54199,12 @@ pub static WORD_REPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_REPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPER_CHILDREN),
+static WORD_REPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esent"),
         dictgen::InsensitiveStr::Ascii("esentation"),
@@ -54244,12 +54244,12 @@ pub static WORD_REPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_REPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEN_CHILDREN),
+static WORD_REPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tence"),
@@ -54259,12 +54259,12 @@ pub static WORD_REPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_REPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEL_CHILDREN),
+static WORD_REPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ases"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -54284,23 +54284,23 @@ pub static WORD_REPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_REPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEI_CHILDREN),
+static WORD_REPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["repetition"]],
     range: 4..=4,
 };
 
-static WORD_REPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPED_CHILDREN),
+static WORD_REPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -54310,12 +54310,12 @@ pub static WORD_REPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_REPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEC_CHILDREN),
+static WORD_REPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("table"),
@@ -54337,12 +54337,12 @@ pub static WORD_REPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_REPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPEA_CHILDREN),
+static WORD_REPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dedly"),
         dictgen::InsensitiveStr::Ascii("detly"),
@@ -54386,12 +54386,12 @@ pub static WORD_REPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPB_CHILDREN),
+static WORD_REPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lic"),
         dictgen::InsensitiveStr::Ascii("lican"),
@@ -54413,12 +54413,12 @@ pub static WORD_REPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_REPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REPA_CHILDREN),
+static WORD_REPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -54502,12 +54502,12 @@ pub static WORD_REPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_REO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REO_CHILDREN),
+static WORD_REO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("admap"),
         dictgen::InsensitiveStr::Ascii("ccuring"),
@@ -54581,12 +54581,12 @@ pub static WORD_REO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_REN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REN_CHILDREN),
+static WORD_REN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REN_CHILDREN),
     value: None,
 };
 
-static WORD_REN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENA_NODE),
     None,
     None,
@@ -54615,23 +54615,23 @@ static WORD_REN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENY_CHILDREN),
+static WORD_RENY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olds")],
     values: &[&["reynolds"]],
     range: 4..=4,
 };
 
-static WORD_RENW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENW_CHILDREN),
+static WORD_RENW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENW_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("eables"),
@@ -54640,23 +54640,23 @@ pub static WORD_RENW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RENU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENU_CHILDREN),
+static WORD_RENU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ion")],
     values: &[&["reunion"]],
     range: 3..=3,
 };
 
-static WORD_RENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENT_CHILDREN),
+static WORD_RENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eris"),
         dictgen::InsensitiveStr::Ascii("ime"),
@@ -54667,12 +54667,12 @@ pub static WORD_RENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_RENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENO_CHILDREN),
+static WORD_RENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sance"),
         dictgen::InsensitiveStr::Ascii("un"),
@@ -54688,12 +54688,12 @@ pub static WORD_RENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENN_CHILDREN),
+static WORD_RENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aisance"),
         dictgen::InsensitiveStr::Ascii("ovate"),
@@ -54711,12 +54711,12 @@ pub static WORD_RENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_RENM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENM_CHILDREN),
+static WORD_RENM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -54725,23 +54725,23 @@ pub static WORD_RENM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_RENK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENK_CHILDREN),
+static WORD_RENK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENK_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eton")],
     values: &[&["renekton"]],
     range: 4..=4,
 };
 
-static WORD_RENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENI_CHILDREN),
+static WORD_RENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("assance"),
         dictgen::InsensitiveStr::Ascii("forcements"),
@@ -54761,23 +54761,23 @@ pub static WORD_RENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_RENG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENG_CHILDREN),
+static WORD_RENG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enerate")],
     values: &[&["regenerate"]],
     range: 7..=7,
 };
 
-static WORD_RENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENF_CHILDREN),
+static WORD_RENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erence"),
         dictgen::InsensitiveStr::Ascii("orce"),
@@ -54797,12 +54797,12 @@ pub static WORD_RENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_RENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENE_CHILDREN),
+static WORD_RENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENE_CHILDREN),
     value: None,
 };
 
-static WORD_RENE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEA_NODE),
     None,
     None,
@@ -54831,12 +54831,12 @@ static WORD_RENE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEW_CHILDREN),
+static WORD_RENEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("abels"),
@@ -54854,23 +54854,23 @@ pub static WORD_RENEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RENET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENET_CHILDREN),
+static WORD_RENET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENET_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("kon")],
     values: &[&["renekton"]],
     range: 3..=3,
 };
 
-static WORD_RENEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENEG_CHILDREN),
+static WORD_RENEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENEG_CHILDREN),
     value: None,
 };
 
-static WORD_RENEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENEG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEGA_NODE),
     None,
     None,
@@ -54899,12 +54899,12 @@ static WORD_RENEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENEGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENEGO_CHILDREN),
+static WORD_RENEGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENEGO_CHILDREN),
     value: None,
 };
 
-static WORD_RENEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENEGO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEGOA_NODE),
     None,
     Some(&WORD_RENEGOC_NODE),
@@ -54933,12 +54933,12 @@ static WORD_RENEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEGOZ_NODE),
 ];
 
-static WORD_RENEGOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOZ_CHILDREN),
+static WORD_RENEGOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -54964,12 +54964,12 @@ pub static WORD_RENEGOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_RENEGOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENEGOT_CHILDREN),
+static WORD_RENEGOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENEGOT_CHILDREN),
     value: None,
 };
 
-static WORD_RENEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENEGOT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RENEGOTA_NODE),
     None,
     None,
@@ -54998,12 +54998,12 @@ static WORD_RENEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENEGOTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RENEGOTI_CHILDREN),
+static WORD_RENEGOTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RENEGOTI_CHILDREN),
     value: None,
 };
 
-static WORD_RENEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RENEGOTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_RENEGOTIB_NODE),
     Some(&WORD_RENEGOTIC_NODE),
@@ -55032,12 +55032,12 @@ static WORD_RENEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RENEGOTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIT_CHILDREN),
+static WORD_RENEGOTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -55095,12 +55095,12 @@ pub static WORD_RENEGOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=6,
 };
 
-static WORD_RENEGOTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIO_CHILDREN),
+static WORD_RENEGOTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -55184,12 +55184,12 @@ pub static WORD_RENEGOTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=7,
 };
 
-static WORD_RENEGOTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIC_CHILDREN),
+static WORD_RENEGOTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -55215,23 +55215,23 @@ pub static WORD_RENEGOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 3..=6,
 };
 
-static WORD_RENEGOTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIB_CHILDREN),
+static WORD_RENEGOTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["renegotiable"]],
     range: 2..=2,
 };
 
-static WORD_RENEGOTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTH_CHILDREN),
+static WORD_RENEGOTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -55257,12 +55257,12 @@ pub static WORD_RENEGOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 4..=7,
 };
 
-static WORD_RENEGOTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTA_CHILDREN),
+static WORD_RENEGOTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -55354,12 +55354,12 @@ pub static WORD_RENEGOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=8,
 };
 
-static WORD_RENEGOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOS_CHILDREN),
+static WORD_RENEGOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -55385,12 +55385,12 @@ pub static WORD_RENEGOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_RENEGOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOP_CHILDREN),
+static WORD_RENEGOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tionsotiable"),
         dictgen::InsensitiveStr::Ascii("tionsotiate"),
@@ -55416,12 +55416,12 @@ pub static WORD_RENEGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 11..=14,
 };
 
-static WORD_RENEGOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOI_CHILDREN),
+static WORD_RENEGOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tate"),
@@ -55447,12 +55447,12 @@ pub static WORD_RENEGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_RENEGOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOG_CHILDREN),
+static WORD_RENEGOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tiable"),
         dictgen::InsensitiveStr::Ascii("tiate"),
@@ -55478,12 +55478,12 @@ pub static WORD_RENEGOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=8,
 };
 
-static WORD_RENEGOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOC_CHILDREN),
+static WORD_RENEGOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -55509,12 +55509,12 @@ pub static WORD_RENEGOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_RENEGOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOA_CHILDREN),
+static WORD_RENEGOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("te"),
@@ -55558,12 +55558,12 @@ pub static WORD_RENEGOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_RENEGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGE_CHILDREN),
+static WORD_RENEGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rate"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -55572,12 +55572,12 @@ pub static WORD_RENEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_RENEGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEGA_CHILDREN),
+static WORD_RENEGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -55607,34 +55607,34 @@ pub static WORD_RENEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_RENED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENED_CHILDREN),
+static WORD_RENED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENED_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ered")],
     values: &[&["rende", "rendered"]],
     range: 4..=4,
 };
 
-static WORD_RENEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENEA_CHILDREN),
+static WORD_RENEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gde")],
     values: &[&["renegade"]],
     range: 3..=3,
 };
 
-static WORD_REND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REND_CHILDREN),
+static WORD_REND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REND_CHILDREN),
     value: None,
 };
 
-pub static WORD_REND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayvoo"),
         dictgen::InsensitiveStr::Ascii("ayvooed"),
@@ -55708,12 +55708,12 @@ pub static WORD_REND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RENA_CHILDREN),
+static WORD_RENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iisance"),
         dictgen::InsensitiveStr::Ascii("iscance"),
@@ -55737,12 +55737,12 @@ pub static WORD_RENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_REM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REM_CHILDREN),
+static WORD_REM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REM_CHILDREN),
     value: None,
 };
 
-static WORD_REM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REMA_NODE),
     Some(&WORD_REMB_NODE),
     None,
@@ -55771,12 +55771,12 @@ static WORD_REM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REMV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMV_CHILDREN),
+static WORD_REMV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMV_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -55804,34 +55804,34 @@ pub static WORD_REMV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_REMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMT_CHILDREN),
+static WORD_REMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oe")],
     values: &[&["remote"]],
     range: 2..=2,
 };
 
-static WORD_REMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMP_CHILDREN),
+static WORD_REMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lacement")],
     values: &[&["replacement"]],
     range: 8..=8,
 };
 
-static WORD_REMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMO_CHILDREN),
+static WORD_REMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -55877,23 +55877,23 @@ pub static WORD_REMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMN_CHILDREN),
+static WORD_REMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ans")],
     values: &[&["remnants"]],
     range: 3..=3,
 };
 
-static WORD_REMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMM_CHILDREN),
+static WORD_REMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apped"),
         dictgen::InsensitiveStr::Ascii("ber"),
@@ -55917,12 +55917,12 @@ pub static WORD_REMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMI_CHILDREN),
+static WORD_REMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("ander"),
@@ -56000,12 +56000,12 @@ pub static WORD_REMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_REME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REME_CHILDREN),
+static WORD_REME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REME_CHILDREN),
     value: None,
 };
 
-pub static WORD_REME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("bered"),
@@ -56095,12 +56095,12 @@ pub static WORD_REME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_REMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMB_CHILDREN),
+static WORD_REMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ember"),
         dictgen::InsensitiveStr::Ascii("embered"),
@@ -56118,12 +56118,12 @@ pub static WORD_REMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REMA_CHILDREN),
+static WORD_REMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ind"),
         dictgen::InsensitiveStr::Ascii("inds"),
@@ -56191,12 +56191,12 @@ pub static WORD_REMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REL_CHILDREN),
+static WORD_REL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REL_CHILDREN),
     value: None,
 };
 
-static WORD_REL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RELA_NODE),
     None,
     Some(&WORD_RELC_NODE),
@@ -56225,12 +56225,12 @@ static WORD_REL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RELY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELY_CHILDREN),
+static WORD_RELY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ably"),
@@ -56248,23 +56248,23 @@ pub static WORD_RELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_RELV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELV_CHILDREN),
+static WORD_RELV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ant")],
     values: &[&["relevant"]],
     range: 3..=3,
 };
 
-static WORD_RELU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELU_CHILDREN),
+static WORD_RELU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctanct"),
         dictgen::InsensitiveStr::Ascii("ctanctly"),
@@ -56282,12 +56282,12 @@ pub static WORD_RELU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_RELT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELT_CHILDREN),
+static WORD_RELT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aionship"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -56296,12 +56296,12 @@ pub static WORD_RELT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RELP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELP_CHILDREN),
+static WORD_RELP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acement"),
         dictgen::InsensitiveStr::Ascii("ase"),
@@ -56312,12 +56312,12 @@ pub static WORD_RELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_RELO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELO_CHILDREN),
+static WORD_RELO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actes"),
         dictgen::InsensitiveStr::Ascii("ade"),
@@ -56369,23 +56369,23 @@ pub static WORD_RELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RELM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELM_CHILDREN),
+static WORD_RELM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELM_CHILDREN),
     value: Some(&["elm", "helm", "realm", "ream", "rem"]),
 };
 
-pub static WORD_RELM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["elms", "helms", "realms", "reams"]],
     range: 1..=1,
 };
 
-static WORD_RELL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELL_CHILDREN),
+static WORD_RELL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocates"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -56394,12 +56394,12 @@ pub static WORD_RELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RELI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELI_CHILDREN),
+static WORD_RELI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("abillity"),
@@ -56475,12 +56475,12 @@ pub static WORD_RELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_RELG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELG_CHILDREN),
+static WORD_RELG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ious"),
@@ -56489,12 +56489,12 @@ pub static WORD_RELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_RELF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELF_CHILDREN),
+static WORD_RELF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -56518,12 +56518,12 @@ pub static WORD_RELF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RELE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RELE_CHILDREN),
+static WORD_RELE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RELE_CHILDREN),
     value: None,
 };
 
-static WORD_RELE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RELE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RELEA_NODE),
     None,
     Some(&WORD_RELEC_NODE),
@@ -56552,23 +56552,23 @@ static WORD_RELE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RELEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEX_CHILDREN),
+static WORD_RELEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["relegation"]],
     range: 5..=5,
 };
 
-static WORD_RELEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEV_CHILDREN),
+static WORD_RELEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abt"),
         dictgen::InsensitiveStr::Ascii("ane"),
@@ -56596,12 +56596,12 @@ pub static WORD_RELEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RELET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELET_CHILDREN),
+static WORD_RELET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELET_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -56623,12 +56623,12 @@ pub static WORD_RELET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RELES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELES_CHILDREN),
+static WORD_RELES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELES_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -56648,23 +56648,23 @@ pub static WORD_RELES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_RELEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEO_CHILDREN),
+static WORD_RELEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ad")],
     values: &[&["reload"]],
     range: 2..=2,
 };
 
-static WORD_RELEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEN_CHILDREN),
+static WORD_RELEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tlesly"),
         dictgen::InsensitiveStr::Ascii("tlessely"),
@@ -56682,12 +56682,12 @@ pub static WORD_RELEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_RELEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEI_CHILDREN),
+static WORD_RELEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("fe"),
@@ -56715,12 +56715,12 @@ pub static WORD_RELEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_RELEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEG_CHILDREN),
+static WORD_RELEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ato"),
         dictgen::InsensitiveStr::Ascii("etion"),
@@ -56729,23 +56729,23 @@ pub static WORD_RELEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_RELEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEE_CHILDREN),
+static WORD_RELEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ction")],
     values: &[&["reelection"]],
     range: 5..=5,
 };
 
-static WORD_RELEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEC_CHILDREN),
+static WORD_RELEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -56761,12 +56761,12 @@ pub static WORD_RELEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_RELEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELEA_CHILDREN),
+static WORD_RELEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -56838,12 +56838,12 @@ pub static WORD_RELEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_RELC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELC_CHILDREN),
+static WORD_RELC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aim"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -56859,12 +56859,12 @@ pub static WORD_RELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_RELA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RELA_CHILDREN),
+static WORD_RELA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RELA_CHILDREN),
     value: Some(&["real"]),
 };
 
-static WORD_RELA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RELA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RELAA_NODE),
     None,
     Some(&WORD_RELAC_NODE),
@@ -56893,34 +56893,34 @@ static WORD_RELA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_RELAZ_NODE),
 ];
 
-static WORD_RELAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAZ_CHILDREN),
+static WORD_RELAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["relaxation"]],
     range: 5..=5,
 };
 
-static WORD_RELAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAX_CHILDREN),
+static WORD_RELAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ating")],
     values: &[&["relaxation"]],
     range: 5..=5,
 };
 
-static WORD_RELAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAV_CHILDREN),
+static WORD_RELAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -56936,12 +56936,12 @@ pub static WORD_RELAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_RELAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAT_CHILDREN),
+static WORD_RELAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("aive"),
@@ -57021,12 +57021,12 @@ pub static WORD_RELAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_RELAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAS_CHILDREN),
+static WORD_RELAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -57052,23 +57052,23 @@ pub static WORD_RELAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_RELAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAP_CHILDREN),
+static WORD_RELAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["relapse"]],
     range: 2..=2,
 };
 
-static WORD_RELAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAO_CHILDREN),
+static WORD_RELAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -57079,23 +57079,23 @@ pub static WORD_RELAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_RELAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAL_CHILDREN),
+static WORD_RELAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["really"]],
     range: 1..=1,
 };
 
-static WORD_RELAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAI_CHILDREN),
+static WORD_RELAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -57123,12 +57123,12 @@ pub static WORD_RELAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_RELAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAG_CHILDREN),
+static WORD_RELAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -57137,12 +57137,12 @@ pub static WORD_RELAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RELAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAE_CHILDREN),
+static WORD_RELAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -57160,23 +57160,23 @@ pub static WORD_RELAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_RELAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAD_CHILDREN),
+static WORD_RELAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["ready"]],
     range: 1..=1,
 };
 
-static WORD_RELAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAC_CHILDREN),
+static WORD_RELAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atable"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -57185,23 +57185,23 @@ pub static WORD_RELAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_RELAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RELAA_CHILDREN),
+static WORD_RELAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RELAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RELAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RELAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tive")],
     values: &[&["relative"]],
     range: 4..=4,
 };
 
-static WORD_REK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REK_CHILDREN),
+static WORD_REK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REK_CHILDREN),
     value: None,
 };
 
-pub static WORD_REK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("enton"),
@@ -57227,12 +57227,12 @@ pub static WORD_REK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_REJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REJ_CHILDREN),
+static WORD_REJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cted"),
         dictgen::InsensitiveStr::Ascii("place"),
@@ -57241,12 +57241,12 @@ pub static WORD_REJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_REI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REI_CHILDREN),
+static WORD_REI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REI_CHILDREN),
     value: None,
 };
 
-static WORD_REI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_REIC_NODE),
@@ -57275,12 +57275,12 @@ static WORD_REI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIV_CHILDREN),
+static WORD_REIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ew"),
         dictgen::InsensitiveStr::Ascii("ews"),
@@ -57290,12 +57290,12 @@ pub static WORD_REIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_REIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIT_CHILDREN),
+static WORD_REIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rement"),
         dictgen::InsensitiveStr::Ascii("res"),
@@ -57313,12 +57313,12 @@ pub static WORD_REIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_REIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIS_CHILDREN),
+static WORD_REIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntall"),
         dictgen::InsensitiveStr::Ascii("ntalled"),
@@ -57336,12 +57336,12 @@ pub static WORD_REIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIP_CHILDREN),
+static WORD_REIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ient"),
         dictgen::InsensitiveStr::Ascii("ients"),
@@ -57350,12 +57350,12 @@ pub static WORD_REIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_REIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIN_CHILDREN),
+static WORD_REIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("assance"),
         dictgen::InsensitiveStr::Ascii("carantion"),
@@ -57459,12 +57459,12 @@ pub static WORD_REIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_REIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIM_CHILDREN),
+static WORD_REIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bursment"),
         dictgen::InsensitiveStr::Ascii("plemenet"),
@@ -57514,12 +57514,12 @@ pub static WORD_REIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=13,
 };
 
-static WORD_REIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIG_CHILDREN),
+static WORD_REIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ht"),
         dictgen::InsensitiveStr::Ascii("ining"),
@@ -57553,12 +57553,12 @@ pub static WORD_REIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REIC_CHILDREN),
+static WORD_REIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arnation"),
         dictgen::InsensitiveStr::Ascii("eved"),
@@ -57567,12 +57567,12 @@ pub static WORD_REIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_REH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REH_CHILDREN),
+static WORD_REH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REH_CHILDREN),
     value: None,
 };
 
-pub static WORD_REH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abilitacion"),
         dictgen::InsensitiveStr::Ascii("abilitaion"),
@@ -57600,12 +57600,12 @@ pub static WORD_REH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_REG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REG_CHILDREN),
+static WORD_REG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REG_CHILDREN),
     value: None,
 };
 
-static WORD_REG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REGA_NODE),
     None,
     Some(&WORD_REGC_NODE),
@@ -57634,23 +57634,23 @@ static WORD_REG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REGY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGY_CHILDREN),
+static WORD_REGY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGY_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lar")],
     values: &[&["regular"]],
     range: 3..=3,
 };
 
-static WORD_REGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REGU_CHILDREN),
+static WORD_REGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REGU_CHILDREN),
     value: None,
 };
 
-static WORD_REGU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REGU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REGUA_NODE),
     None,
     None,
@@ -57679,23 +57679,23 @@ static WORD_REGU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REGUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUS_CHILDREN),
+static WORD_REGUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["register"]],
     range: 3..=3,
 };
 
-static WORD_REGUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUR_CHILDREN),
+static WORD_REGUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -57705,12 +57705,12 @@ pub static WORD_REGUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_REGUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUL_CHILDREN),
+static WORD_REGUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -57820,12 +57820,12 @@ pub static WORD_REGUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_REGUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUI_CHILDREN),
+static WORD_REGUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("re"),
         dictgen::InsensitiveStr::Ascii("red"),
@@ -57845,12 +57845,12 @@ pub static WORD_REGUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REGUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGUA_CHILDREN),
+static WORD_REGUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lar"),
         dictgen::InsensitiveStr::Ascii("larly"),
@@ -57906,12 +57906,12 @@ pub static WORD_REGUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_REGS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGS_CHILDREN),
+static WORD_REGS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -57951,12 +57951,12 @@ pub static WORD_REGS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGR_CHILDREN),
+static WORD_REGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adless"),
         dictgen::InsensitiveStr::Ascii("ads"),
@@ -58006,12 +58006,12 @@ pub static WORD_REGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGO_CHILDREN),
+static WORD_REGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cnition"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -58029,23 +58029,23 @@ pub static WORD_REGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_REGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGL_CHILDREN),
+static WORD_REGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uar")],
     values: &[&["regular"]],
     range: 3..=3,
 };
 
-static WORD_REGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGI_CHILDREN),
+static WORD_REGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dstered"),
         dictgen::InsensitiveStr::Ascii("ems"),
@@ -58175,12 +58175,12 @@ pub static WORD_REGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_REGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGE_CHILDREN),
+static WORD_REGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ister"),
         dictgen::InsensitiveStr::Ascii("istered"),
@@ -58234,23 +58234,23 @@ pub static WORD_REGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_REGC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGC_CHILDREN),
+static WORD_REGC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onized")],
     values: &[&["recognized"]],
     range: 6..=6,
 };
 
-static WORD_REGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REGA_CHILDREN),
+static WORD_REGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -58306,12 +58306,12 @@ pub static WORD_REGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_REF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REF_CHILDREN),
+static WORD_REF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REF_CHILDREN),
     value: None,
 };
 
-static WORD_REF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REFA_NODE),
     None,
     Some(&WORD_REFC_NODE),
@@ -58340,12 +58340,12 @@ static WORD_REF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFU_CHILDREN),
+static WORD_REFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("brished"),
         dictgen::InsensitiveStr::Ascii("dn"),
@@ -58367,12 +58367,12 @@ pub static WORD_REFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFR_CHILDREN),
+static WORD_REFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eh"),
         dictgen::InsensitiveStr::Ascii("ehser"),
@@ -58452,12 +58452,12 @@ pub static WORD_REFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_REFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFO_CHILDREN),
+static WORD_REFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cuss"),
         dictgen::InsensitiveStr::Ascii("cussed"),
@@ -58479,12 +58479,12 @@ pub static WORD_REFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_REFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFL_CHILDREN),
+static WORD_REFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eciton"),
         dictgen::InsensitiveStr::Ascii("ecte"),
@@ -58522,12 +58522,12 @@ pub static WORD_REFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFI_CHILDREN),
+static WORD_REFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ined"),
         dictgen::InsensitiveStr::Ascii("lles"),
@@ -58549,12 +58549,12 @@ pub static WORD_REFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_REFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFF_CHILDREN),
+static WORD_REFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("eral"),
@@ -58580,12 +58580,12 @@ pub static WORD_REFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_REFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REFE_CHILDREN),
+static WORD_REFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REFE_CHILDREN),
     value: None,
 };
 
-static WORD_REFE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REFE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_REFEC_NODE),
@@ -58614,12 +58614,12 @@ static WORD_REFE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REFES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFES_CHILDREN),
+static WORD_REFES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFES_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hed"),
@@ -58635,12 +58635,12 @@ pub static WORD_REFES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_REFER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REFER_CHILDREN),
+static WORD_REFER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REFER_CHILDREN),
     value: None,
 };
 
-static WORD_REFER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REFER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REFERA_NODE),
     None,
     None,
@@ -58669,23 +58669,23 @@ static WORD_REFER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REFERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERU_CHILDREN),
+static WORD_REFERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ndum")],
     values: &[&["referendum"]],
     range: 4..=4,
 };
 
-static WORD_REFERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERT_CHILDREN),
+static WORD_REFERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -58695,12 +58695,12 @@ pub static WORD_REFERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_REFERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERS_CHILDREN),
+static WORD_REFERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hed"),
         dictgen::InsensitiveStr::Ascii("her"),
@@ -58709,12 +58709,12 @@ pub static WORD_REFERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=3,
 };
 
-static WORD_REFERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERR_CHILDREN),
+static WORD_REFERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERR_CHILDREN),
     value: Some(&["refer"]),
 };
 
-pub static WORD_REFERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -58738,12 +58738,12 @@ pub static WORD_REFERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_REFERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERN_CHILDREN),
+static WORD_REFERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -58773,12 +58773,12 @@ pub static WORD_REFERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_REFERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERI_CHILDREN),
+static WORD_REFERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ang"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -58798,12 +58798,12 @@ pub static WORD_REFERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_REFERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERE_CHILDREN),
+static WORD_REFERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERE_CHILDREN),
     value: Some(&["refer", "referee"]),
 };
 
-pub static WORD_REFERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bces"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -58915,12 +58915,12 @@ pub static WORD_REFERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_REFERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFERA_CHILDREN),
+static WORD_REFERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ls"),
@@ -58944,12 +58944,12 @@ pub static WORD_REFERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_REFEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEN_CHILDREN),
+static WORD_REFEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -58967,12 +58967,12 @@ pub static WORD_REFEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_REFEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEL_CHILDREN),
+static WORD_REFEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -58998,12 +58998,12 @@ pub static WORD_REFEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_REFEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEI_CHILDREN),
+static WORD_REFEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nement"),
         dictgen::InsensitiveStr::Ascii("nements"),
@@ -59012,34 +59012,34 @@ pub static WORD_REFEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_REFEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEE_CHILDREN),
+static WORD_REFEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("res")],
     values: &[&["referees"]],
     range: 3..=3,
 };
 
-static WORD_REFED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFED_CHILDREN),
+static WORD_REFED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFED_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("endum")],
     values: &[&["referendum"]],
     range: 5..=5,
 };
 
-static WORD_REFEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFEC_CHILDREN),
+static WORD_REFEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -59061,12 +59061,12 @@ pub static WORD_REFEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_REFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFC_CHILDREN),
+static WORD_REFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ound"),
         dictgen::InsensitiveStr::Ascii("ounf"),
@@ -59075,12 +59075,12 @@ pub static WORD_REFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_REFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REFA_CHILDREN),
+static WORD_REFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cor"),
         dictgen::InsensitiveStr::Ascii("rtor"),
@@ -59096,12 +59096,12 @@ pub static WORD_REFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_REE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REE_CHILDREN),
+static WORD_REE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -59187,12 +59187,12 @@ pub static WORD_REE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_RED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RED_CHILDREN),
+static WORD_RED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RED_CHILDREN),
     value: None,
 };
 
-static WORD_RED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RED_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REDA_NODE),
     None,
     Some(&WORD_REDC_NODE),
@@ -59221,23 +59221,23 @@ static WORD_RED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REDY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDY_CHILDREN),
+static WORD_REDY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDY_CHILDREN),
     value: Some(&["ready", "red"]),
 };
 
-pub static WORD_REDY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_REDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDU_CHILDREN),
+static WORD_REDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceable"),
         dictgen::InsensitiveStr::Ascii("dancy"),
@@ -59287,23 +59287,23 @@ pub static WORD_REDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_REDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDO_CHILDREN),
+static WORD_REDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nly")],
     values: &[&["readonly"]],
     range: 3..=3,
 };
 
-static WORD_REDN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDN_CHILDREN),
+static WORD_REDN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eckers"),
         dictgen::InsensitiveStr::Ascii("eckese"),
@@ -59321,34 +59321,34 @@ pub static WORD_REDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REDM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDM_CHILDREN),
+static WORD_REDM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDM_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eption")],
     values: &[&["redemption"]],
     range: 6..=6,
 };
 
-static WORD_REDL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDL_CHILDREN),
+static WORD_REDL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDL_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iens")],
     values: &[&["redlines"]],
     range: 4..=4,
 };
 
-static WORD_REDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDI_CHILDREN),
+static WORD_REDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cilous"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -59426,12 +59426,12 @@ pub static WORD_REDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_REDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDE_CHILDREN),
+static WORD_REDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("claation"),
@@ -59483,12 +59483,12 @@ pub static WORD_REDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDC_CHILDREN),
+static WORD_REDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("ue"),
@@ -59497,12 +59497,12 @@ pub static WORD_REDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_REDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REDA_CHILDREN),
+static WORD_REDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -59518,12 +59518,12 @@ pub static WORD_REDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REC_CHILDREN),
+static WORD_REC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REC_CHILDREN),
     value: None,
 };
 
-static WORD_REC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RECA_NODE),
     None,
     Some(&WORD_RECC_NODE),
@@ -59552,12 +59552,12 @@ static WORD_REC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RECY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECY_CHILDREN),
+static WORD_RECY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECY_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clying"),
         dictgen::InsensitiveStr::Ascii("lcing"),
@@ -59577,23 +59577,23 @@ pub static WORD_RECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RECV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECV_CHILDREN),
+static WORD_RECV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ied")],
     values: &[&["received"]],
     range: 3..=3,
 };
 
-static WORD_RECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECU_CHILDREN),
+static WORD_RECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("iting"),
@@ -59683,12 +59683,12 @@ pub static WORD_RECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_RECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECT_CHILDREN),
+static WORD_RECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("angel"),
@@ -59724,12 +59724,12 @@ pub static WORD_RECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_RECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECR_CHILDREN),
+static WORD_RECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("ational"),
@@ -59817,23 +59817,23 @@ pub static WORD_RECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RECQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECQ_CHILDREN),
+static WORD_RECQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uired")],
     values: &[&["required"]],
     range: 5..=5,
 };
 
-static WORD_RECP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECP_CHILDREN),
+static WORD_RECP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etionist"),
         dictgen::InsensitiveStr::Ascii("etive"),
@@ -59851,12 +59851,12 @@ pub static WORD_RECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RECO_CHILDREN),
+static WORD_RECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RECO_CHILDREN),
     value: None,
 };
 
-static WORD_RECO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RECO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_RECOC_NODE),
@@ -59885,12 +59885,12 @@ static WORD_RECO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RECOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOV_CHILDREN),
+static WORD_RECOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("eres"),
@@ -59910,12 +59910,12 @@ pub static WORD_RECOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_RECOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOU_CHILDREN),
+static WORD_RECOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rce"),
         dictgen::InsensitiveStr::Ascii("rced"),
@@ -59931,23 +59931,23 @@ pub static WORD_RECOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_RECOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOS_CHILDREN),
+static WORD_RECOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("truct")],
     values: &[&["reconstruct"]],
     range: 5..=5,
 };
 
-static WORD_RECOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOR_CHILDREN),
+static WORD_RECOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dare"),
         dictgen::InsensitiveStr::Ascii("darle"),
@@ -59977,12 +59977,12 @@ pub static WORD_RECOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_RECON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RECON_CHILDREN),
+static WORD_RECON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RECON_CHILDREN),
     value: None,
 };
 
-static WORD_RECON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RECON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RECONA_NODE),
     None,
     Some(&WORD_RECONC_NODE),
@@ -60011,12 +60011,12 @@ static WORD_RECON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RECONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONT_CHILDREN),
+static WORD_RECONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ruct"),
         dictgen::InsensitiveStr::Ascii("ructed"),
@@ -60040,12 +60040,12 @@ pub static WORD_RECONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_RECONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONS_CHILDREN),
+static WORD_RECONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idder"),
         dictgen::InsensitiveStr::Ascii("iled"),
@@ -60083,12 +60083,12 @@ pub static WORD_RECONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_RECONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONN_CHILDREN),
+static WORD_RECONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aisance"),
         dictgen::InsensitiveStr::Ascii("aissence"),
@@ -60112,12 +60112,12 @@ pub static WORD_RECONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_RECONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONI_CHILDREN),
+static WORD_RECONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cle"),
         dictgen::InsensitiveStr::Ascii("sder"),
@@ -60135,12 +60135,12 @@ pub static WORD_RECONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_RECONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONG_CHILDREN),
+static WORD_RECONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifure"),
         dictgen::InsensitiveStr::Ascii("ise"),
@@ -60174,12 +60174,12 @@ pub static WORD_RECONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_RECONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONF_CHILDREN),
+static WORD_RECONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifure"),
         dictgen::InsensitiveStr::Ascii("iged"),
@@ -60199,12 +60199,12 @@ pub static WORD_RECONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_RECONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONE_CHILDREN),
+static WORD_RECONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cct"),
         dictgen::InsensitiveStr::Ascii("ccted"),
@@ -60272,23 +60272,23 @@ pub static WORD_RECONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_RECOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOND_CHILDREN),
+static WORD_RECOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ifure")],
     values: &[&["reconfigure"]],
     range: 5..=5,
 };
 
-static WORD_RECONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONC_CHILDREN),
+static WORD_RECONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ider"),
         dictgen::InsensitiveStr::Ascii("ilation"),
@@ -60306,12 +60306,12 @@ pub static WORD_RECONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_RECONA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECONA_CHILDREN),
+static WORD_RECONA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECONA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECONA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("issance"),
         dictgen::InsensitiveStr::Ascii("sence"),
@@ -60320,12 +60320,12 @@ pub static WORD_RECONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=7,
 };
 
-static WORD_RECOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RECOM_CHILDREN),
+static WORD_RECOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RECOM_CHILDREN),
     value: None,
 };
 
-static WORD_RECOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RECOM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_RECOMA_NODE),
     None,
     None,
@@ -60354,12 +60354,12 @@ static WORD_RECOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RECOMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOMP_CHILDREN),
+static WORD_RECOMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("lie"),
@@ -60383,12 +60383,12 @@ pub static WORD_RECOMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_RECOMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOMM_CHILDREN),
+static WORD_RECOMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -60494,23 +60494,23 @@ pub static WORD_RECOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_RECOMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOMI_CHILDREN),
+static WORD_RECOMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nant")],
     values: &[&["recombinant"]],
     range: 4..=4,
 };
 
-static WORD_RECOME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOME_CHILDREN),
+static WORD_RECOME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOME_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ndation"),
@@ -60534,34 +60534,34 @@ pub static WORD_RECOME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_RECOMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOMA_CHILDREN),
+static WORD_RECOMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nded")],
     values: &[&["recommended"]],
     range: 4..=4,
 };
 
-static WORD_RECOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOL_CHILDREN),
+static WORD_RECOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("leciton")],
     values: &[&["recollection"]],
     range: 7..=7,
 };
 
-static WORD_RECOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOG_CHILDREN),
+static WORD_RECOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inizer"),
         dictgen::InsensitiveStr::Ascii("inse"),
@@ -60613,34 +60613,34 @@ pub static WORD_RECOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RECOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOF_CHILDREN),
+static WORD_RECOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ig")],
     values: &[&["reconfig"]],
     range: 2..=2,
 };
 
-static WORD_RECOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOD_CHILDREN),
+static WORD_RECOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOD_CHILDREN),
     value: Some(&["record"]),
 };
 
-pub static WORD_RECOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_RECOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECOC_CHILDREN),
+static WORD_RECOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("nisable"),
@@ -60654,12 +60654,12 @@ pub static WORD_RECOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_RECN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECN_CHILDREN),
+static WORD_RECN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tly"),
@@ -60668,12 +60668,12 @@ pub static WORD_RECN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_RECL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECL_CHILDREN),
+static WORD_RECL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aimation"),
         dictgen::InsensitiveStr::Ascii("ami"),
@@ -60691,23 +60691,23 @@ pub static WORD_RECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_RECK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECK_CHILDREN),
+static WORD_RECK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECK_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ognize")],
     values: &[&["recognize"]],
     range: 6..=6,
 };
 
-static WORD_RECJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECJ_CHILDREN),
+static WORD_RECJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -60718,12 +60718,12 @@ pub static WORD_RECJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_RECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECI_CHILDREN),
+static WORD_RECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -60831,12 +60831,12 @@ pub static WORD_RECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RECH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECH_CHILDREN),
+static WORD_RECH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECH_CHILDREN),
     value: Some(&["reach"]),
 };
 
-pub static WORD_RECH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("aged"),
@@ -60856,12 +60856,12 @@ pub static WORD_RECH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_RECG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECG_CHILDREN),
+static WORD_RECG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECG_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onise"),
         dictgen::InsensitiveStr::Ascii("onised"),
@@ -60885,12 +60885,12 @@ pub static WORD_RECG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_RECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECE_CHILDREN),
+static WORD_RECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eded"),
         dictgen::InsensitiveStr::Ascii("eding"),
@@ -61014,12 +61014,12 @@ pub static WORD_RECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_RECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECC_CHILDREN),
+static WORD_RECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omend"),
         dictgen::InsensitiveStr::Ascii("omendation"),
@@ -61125,12 +61125,12 @@ pub static WORD_RECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_RECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RECA_CHILDREN),
+static WORD_RECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_RECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hed"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -61184,12 +61184,12 @@ pub static WORD_RECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_REB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REB_CHILDREN),
+static WORD_REB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REB_CHILDREN),
     value: None,
 };
 
-pub static WORD_REB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ease"),
         dictgen::InsensitiveStr::Ascii("ellios"),
@@ -61263,12 +61263,12 @@ pub static WORD_REB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_REA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REA_CHILDREN),
+static WORD_REA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REA_CHILDREN),
     value: None,
 };
 
-static WORD_REA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REAA_NODE),
     None,
     Some(&WORD_REAC_NODE),
@@ -61297,23 +61297,23 @@ static WORD_REA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAY_CHILDREN),
+static WORD_REAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAY_CHILDREN),
     value: Some(&["ready", "really", "ray"]),
 };
 
-pub static WORD_REAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["ready", "read"]],
     range: 1..=1,
 };
 
-static WORD_REAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAV_CHILDREN),
+static WORD_REAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ealed"),
         dictgen::InsensitiveStr::Ascii("eled"),
@@ -61323,23 +61323,23 @@ pub static WORD_REAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_REAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAU_CHILDREN),
+static WORD_REAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ires")],
     values: &[&["requires"]],
     range: 4..=4,
 };
 
-static WORD_REAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAT_CHILDREN),
+static WORD_REAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -61363,12 +61363,12 @@ pub static WORD_REAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_REAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAS_CHILDREN),
+static WORD_REAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earch"),
         dictgen::InsensitiveStr::Ascii("earcher"),
@@ -61436,12 +61436,12 @@ pub static WORD_REAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAR_CHILDREN),
+static WORD_REAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angement"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -61537,23 +61537,23 @@ pub static WORD_REAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_REAQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAQ_CHILDREN),
+static WORD_REAQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uire")],
     values: &[&["reacquire", "require"]],
     range: 4..=4,
 };
 
-static WORD_REAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAP_CHILDREN),
+static WORD_REAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eat"),
         dictgen::InsensitiveStr::Ascii("eated"),
@@ -61591,12 +61591,12 @@ pub static WORD_REAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_REAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAO_CHILDREN),
+static WORD_REAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -61605,12 +61605,12 @@ pub static WORD_REAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_REAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAN_CHILDREN),
+static WORD_REAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("me"),
@@ -61628,12 +61628,12 @@ pub static WORD_REAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_REAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAM_CHILDREN),
+static WORD_REAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -61653,12 +61653,12 @@ pub static WORD_REAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_REAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_REAL_CHILDREN),
+static WORD_REAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_REAL_CHILDREN),
     value: None,
 };
 
-static WORD_REAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_REAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_REALA_NODE),
     None,
     None,
@@ -61687,23 +61687,23 @@ static WORD_REAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_REALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALY_CHILDREN),
+static WORD_REALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALY_CHILDREN),
     value: Some(&["really", "relay", "real"]),
 };
 
-pub static WORD_REALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["really"]],
     range: 1..=1,
 };
 
-static WORD_REALT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALT_CHILDREN),
+static WORD_REALT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALT_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -61733,12 +61733,12 @@ pub static WORD_REALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALS_CHILDREN),
+static WORD_REALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -61756,12 +61756,12 @@ pub static WORD_REALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_REALO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALO_CHILDREN),
+static WORD_REALO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALO_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -61770,12 +61770,12 @@ pub static WORD_REALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALL_CHILDREN),
+static WORD_REALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALL_CHILDREN),
     value: Some(&["real", "really", "recall"]),
 };
 
-pub static WORD_REALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ize"),
@@ -61819,12 +61819,12 @@ pub static WORD_REALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_REALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALI_CHILDREN),
+static WORD_REALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("bility"),
@@ -61872,12 +61872,12 @@ pub static WORD_REALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_REALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALE_CHILDREN),
+static WORD_REALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -61887,12 +61887,12 @@ pub static WORD_REALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_REALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REALA_CHILDREN),
+static WORD_REALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ted"),
         dictgen::InsensitiveStr::Ascii("tionship"),
@@ -61902,12 +61902,12 @@ pub static WORD_REALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_REAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAK_CHILDREN),
+static WORD_REAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("point"),
         dictgen::InsensitiveStr::Ascii("tivate"),
@@ -61917,23 +61917,23 @@ pub static WORD_REAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_REAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAI_CHILDREN),
+static WORD_REAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("se")],
     values: &[&["realise", "raise"]],
     range: 2..=2,
 };
 
-static WORD_REAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAG_CHILDREN),
+static WORD_REAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arding"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -61944,12 +61944,12 @@ pub static WORD_REAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_REAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAE_CHILDREN),
+static WORD_REAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ched"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -61958,12 +61958,12 @@ pub static WORD_REAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_READ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_READ_CHILDREN),
+static WORD_READ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_READ_CHILDREN),
     value: None,
 };
 
-pub static WORD_READ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_READ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abillity"),
         dictgen::InsensitiveStr::Ascii("abilty"),
@@ -62023,12 +62023,12 @@ pub static WORD_READ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAC_CHILDREN),
+static WORD_REAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahable"),
         dictgen::InsensitiveStr::Ascii("ahble"),
@@ -62070,12 +62070,12 @@ pub static WORD_REAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_REAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_REAA_CHILDREN),
+static WORD_REAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_REAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_REAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_REAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ly"),
         dictgen::InsensitiveStr::Ascii("range"),
@@ -62091,12 +62091,12 @@ pub static WORD_REAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_RD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RD_CHILDREN),
+static WORD_RD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RD_CHILDREN),
     value: None,
 };
 
-pub static WORD_RD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("uce"),
@@ -62105,12 +62105,12 @@ pub static WORD_RD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_RC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RC_CHILDREN),
+static WORD_RC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("eate"),
@@ -62120,12 +62120,12 @@ pub static WORD_RC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_RA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_RA_CHILDREN),
+static WORD_RA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_RA_CHILDREN),
     value: None,
 };
 
-static WORD_RA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_RA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_RAB_NODE),
     Some(&WORD_RAC_NODE),
@@ -62154,12 +62154,12 @@ static WORD_RA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_RAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAT_CHILDREN),
+static WORD_RAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atooee"),
         dictgen::InsensitiveStr::Ascii("atoolee"),
@@ -62199,12 +62199,12 @@ pub static WORD_RAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_RAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAS_CHILDREN),
+static WORD_RAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("berry"),
         dictgen::InsensitiveStr::Ascii("bperries"),
@@ -62238,12 +62238,12 @@ pub static WORD_RAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_RAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAR_CHILDREN),
+static WORD_RAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elly"),
         dictgen::InsensitiveStr::Ascii("ified"),
@@ -62252,23 +62252,23 @@ pub static WORD_RAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_RAQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAQ_CHILDREN),
+static WORD_RAQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uetball")],
     values: &[&["racquetball"]],
     range: 7..=7,
 };
 
-static WORD_RAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAP_CHILDREN),
+static WORD_RAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("air"),
         dictgen::InsensitiveStr::Ascii("ell"),
@@ -62320,12 +62320,12 @@ pub static WORD_RAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_RAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAO_CHILDREN),
+static WORD_RAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ches"),
         dictgen::InsensitiveStr::Ascii("ming"),
@@ -62355,12 +62355,12 @@ pub static WORD_RAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_RAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAN_CHILDREN),
+static WORD_RAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dam"),
         dictgen::InsensitiveStr::Ascii("dayvoo"),
@@ -62418,12 +62418,12 @@ pub static WORD_RAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_RAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAM_CHILDREN),
+static WORD_RAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ains"),
         dictgen::InsensitiveStr::Ascii("domly"),
@@ -62433,12 +62433,12 @@ pub static WORD_RAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_RAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAL_CHILDREN),
+static WORD_RAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -62447,12 +62447,12 @@ pub static WORD_RAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_RAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAI_CHILDREN),
+static WORD_RAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dance"),
         dictgen::InsensitiveStr::Ascii("dant"),
@@ -62478,12 +62478,12 @@ pub static WORD_RAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_RAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAH_CHILDREN),
+static WORD_RAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("psody"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -62492,12 +62492,12 @@ pub static WORD_RAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_RAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAE_CHILDREN),
+static WORD_RAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -62517,12 +62517,12 @@ pub static WORD_RAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_RAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAD_CHILDREN),
+static WORD_RAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aince"),
         dictgen::InsensitiveStr::Ascii("aint"),
@@ -62592,12 +62592,12 @@ pub static WORD_RAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_RAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAC_CHILDREN),
+static WORD_RAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aus"),
         dictgen::InsensitiveStr::Ascii("hives"),
@@ -62625,12 +62625,12 @@ pub static WORD_RAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_RAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_RAB_CHILDREN),
+static WORD_RAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_RAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_RAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_RAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bitos"),
         dictgen::InsensitiveStr::Ascii("bitts"),
@@ -62648,12 +62648,12 @@ pub static WORD_RAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_Q_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_Q_CHILDREN),
+static WORD_Q_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_Q_CHILDREN),
     value: None,
 };
 
-static WORD_Q_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_Q_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_QA_NODE),
     None,
     None,
@@ -62682,12 +62682,12 @@ static WORD_Q_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_QW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QW_CHILDREN),
+static WORD_QW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QW_CHILDREN),
     value: None,
 };
 
-pub static WORD_QW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esant"),
         dictgen::InsensitiveStr::Ascii("esants"),
@@ -62703,12 +62703,12 @@ pub static WORD_QW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_QU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_QU_CHILDREN),
+static WORD_QU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_QU_CHILDREN),
     value: None,
 };
 
-static WORD_QU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_QU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_QUA_NODE),
     Some(&WORD_QUB_NODE),
     Some(&WORD_QUC_NODE),
@@ -62737,12 +62737,12 @@ static WORD_QU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_QUW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUW_CHILDREN),
+static WORD_QUW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUW_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esant"),
         dictgen::InsensitiveStr::Ascii("esants"),
@@ -62758,34 +62758,34 @@ pub static WORD_QUW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_QUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUU_CHILDREN),
+static WORD_QUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ery")],
     values: &[&["query"]],
     range: 3..=3,
 };
 
-static WORD_QUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUT_CHILDREN),
+static WORD_QUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ie")],
     values: &[&["quite", "quiet"]],
     range: 2..=2,
 };
 
-static WORD_QUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUS_CHILDREN),
+static WORD_QUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -62796,12 +62796,12 @@ pub static WORD_QUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_QUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUR_CHILDREN),
+static WORD_QUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ey"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -62821,12 +62821,12 @@ pub static WORD_QUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_QUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUO_CHILDREN),
+static WORD_QUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("shant"),
         dictgen::InsensitiveStr::Ascii("shants"),
@@ -62848,12 +62848,12 @@ pub static WORD_QUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_QUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUN_CHILDREN),
+static WORD_QUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atum"),
         dictgen::InsensitiveStr::Ascii("etin"),
@@ -62862,12 +62862,12 @@ pub static WORD_QUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_QUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUL_CHILDREN),
+static WORD_QUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aity"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -62876,12 +62876,12 @@ pub static WORD_QUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_QUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUI_CHILDREN),
+static WORD_QUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bic"),
         dictgen::InsensitiveStr::Ascii("cket"),
@@ -62943,12 +62943,12 @@ pub static WORD_QUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_QUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_QUE_CHILDREN),
+static WORD_QUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_QUE_CHILDREN),
     value: None,
 };
 
-static WORD_QUE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_QUE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_QUEA_NODE),
     None,
     None,
@@ -62977,23 +62977,23 @@ static WORD_QUE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_QUEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEW_CHILDREN),
+static WORD_QUEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEW_CHILDREN),
     value: Some(&["queue"]),
 };
 
-pub static WORD_QUEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_QUEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEU_CHILDREN),
+static WORD_QUEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEU_CHILDREN),
     value: Some(&["queue"]),
 };
 
-pub static WORD_QUEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("eud"),
@@ -63003,12 +63003,12 @@ pub static WORD_QUEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_QUET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUET_CHILDREN),
+static WORD_QUET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUET_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -63018,12 +63018,12 @@ pub static WORD_QUET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_QUES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUES_CHILDREN),
+static WORD_QUES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUES_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -63111,12 +63111,12 @@ pub static WORD_QUES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_QUER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUER_CHILDREN),
+static WORD_QUER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUER_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eis"),
@@ -63144,23 +63144,23 @@ pub static WORD_QUER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_QUEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEN_CHILDREN),
+static WORD_QUEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["quentin"]],
     range: 4..=4,
 };
 
-static WORD_QUEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEI_CHILDREN),
+static WORD_QUEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("res"),
@@ -63178,12 +63178,12 @@ pub static WORD_QUEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_QUEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEE_CHILDREN),
+static WORD_QUEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEE_CHILDREN),
     value: Some(&["queue"]),
 };
 
-pub static WORD_QUEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nland"),
         dictgen::InsensitiveStr::Ascii("ue"),
@@ -63192,12 +63192,12 @@ pub static WORD_QUEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_QUEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUEA_CHILDREN),
+static WORD_QUEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tions"),
@@ -63206,23 +63206,23 @@ pub static WORD_QUEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_QUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUD_CHILDREN),
+static WORD_QUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rangles")],
     values: &[&["quadrangles"]],
     range: 7..=7,
 };
 
-static WORD_QUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUC_CHILDREN),
+static WORD_QUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ik"),
         dictgen::InsensitiveStr::Ascii("ikest"),
@@ -63232,23 +63232,23 @@ pub static WORD_QUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_QUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUB_CHILDREN),
+static WORD_QUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ic")],
     values: &[&["cubic", "qubit"]],
     range: 2..=2,
 };
 
-static WORD_QUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_QUA_CHILDREN),
+static WORD_QUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_QUA_CHILDREN),
     value: None,
 };
 
-static WORD_QUA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_QUA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -63277,12 +63277,12 @@ static WORD_QUA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_QUAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAT_CHILDREN),
+static WORD_QUAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -63312,12 +63312,12 @@ pub static WORD_QUAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_QUAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAR_CHILDREN),
+static WORD_QUAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antaine"),
         dictgen::InsensitiveStr::Ascii("ante"),
@@ -63367,12 +63367,12 @@ pub static WORD_QUAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_QUAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAN_CHILDREN),
+static WORD_QUAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itfy"),
         dictgen::InsensitiveStr::Ascii("ities"),
@@ -63440,12 +63440,12 @@ pub static WORD_QUAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_QUAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAL_CHILDREN),
+static WORD_QUAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fied"),
         dictgen::InsensitiveStr::Ascii("fiiers"),
@@ -63507,12 +63507,12 @@ pub static WORD_QUAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_QUAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAI_CHILDREN),
+static WORD_QUAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfiers"),
         dictgen::InsensitiveStr::Ascii("lfy"),
@@ -63530,12 +63530,12 @@ pub static WORD_QUAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_QUAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAF_CHILDREN),
+static WORD_QUAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eur"),
         dictgen::InsensitiveStr::Ascii("eured"),
@@ -63544,12 +63544,12 @@ pub static WORD_QUAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_QUAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QUAD_CHILDREN),
+static WORD_QUAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QUAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_QUAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QUAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ddec"),
         dictgen::InsensitiveStr::Ascii("ranle"),
@@ -63579,23 +63579,23 @@ pub static WORD_QUAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_QT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QT_CHILDREN),
+static WORD_QT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QT_CHILDREN),
     value: None,
 };
 
-pub static WORD_QT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uie")],
     values: &[&["quite", "quiet"]],
     range: 3..=3,
 };
 
-static WORD_QO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QO_CHILDREN),
+static WORD_QO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QO_CHILDREN),
     value: None,
 };
 
-pub static WORD_QO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uoted"),
         dictgen::InsensitiveStr::Ascii("utation"),
@@ -63617,12 +63617,12 @@ pub static WORD_QO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_QI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QI_CHILDREN),
+static WORD_QI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QI_CHILDREN),
     value: None,
 };
 
-pub static WORD_QI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ests"),
@@ -63632,23 +63632,23 @@ pub static WORD_QI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_QH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QH_CHILDREN),
+static WORD_QH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QH_CHILDREN),
     value: None,
 };
 
-pub static WORD_QH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ich")],
     values: &[&["quiche", "which"]],
     range: 3..=3,
 };
 
-static WORD_QE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QE_CHILDREN),
+static WORD_QE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QE_CHILDREN),
     value: None,
 };
 
-pub static WORD_QE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("st"),
         dictgen::InsensitiveStr::Ascii("stions"),
@@ -63674,12 +63674,12 @@ pub static WORD_QE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_QA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_QA_CHILDREN),
+static WORD_QA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_QA_CHILDREN),
     value: None,
 };
 
-pub static WORD_QA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_QA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ulification"),
         dictgen::InsensitiveStr::Ascii("ulifications"),
@@ -63705,12 +63705,12 @@ pub static WORD_QA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=12,
 };
 
-static WORD_P_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_P_CHILDREN),
+static WORD_P_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_P_CHILDREN),
     value: None,
 };
 
-static WORD_P_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_P_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PA_NODE),
     Some(&WORD_PB_NODE),
     None,
@@ -63739,12 +63739,12 @@ static WORD_P_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PY_CHILDREN),
+static WORD_PY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("armid"),
         dictgen::InsensitiveStr::Ascii("hon"),
@@ -63844,12 +63844,12 @@ pub static WORD_PY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_PX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PX_CHILDREN),
+static WORD_PX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oxied"),
         dictgen::InsensitiveStr::Ascii("oxies"),
@@ -63859,23 +63859,23 @@ pub static WORD_PX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_PW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PW_CHILDREN),
+static WORD_PW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oer")],
     values: &[&["power"]],
     range: 3..=3,
 };
 
-static WORD_PU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PU_CHILDREN),
+static WORD_PU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PU_CHILDREN),
     value: None,
 };
 
-static WORD_PU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PUA_NODE),
     Some(&WORD_PUB_NODE),
     Some(&WORD_PUC_NODE),
@@ -63904,12 +63904,12 @@ static WORD_PU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUT_CHILDREN),
+static WORD_PUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("pose"),
@@ -63920,12 +63920,12 @@ pub static WORD_PUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_PUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUS_CHILDREN),
+static WORD_PUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blishing"),
         dictgen::InsensitiveStr::Ascii("ehd"),
@@ -63936,12 +63936,12 @@ pub static WORD_PUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_PUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUR_CHILDREN),
+static WORD_PUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agtory"),
         dictgen::InsensitiveStr::Ascii("cahed"),
@@ -64033,12 +64033,12 @@ pub static WORD_PUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_PUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUP_CHILDREN),
+static WORD_PUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lar"),
         dictgen::InsensitiveStr::Ascii("larity"),
@@ -64072,12 +64072,12 @@ pub static WORD_PUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_PUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUN_CHILDREN),
+static WORD_PUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctation"),
         dictgen::InsensitiveStr::Ascii("ctiation"),
@@ -64127,12 +64127,12 @@ pub static WORD_PUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_PUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUM_CHILDREN),
+static WORD_PUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kin"),
         dictgen::InsensitiveStr::Ascii("kpins"),
@@ -64143,12 +64143,12 @@ pub static WORD_PUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_PUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUL_CHILDREN),
+static WORD_PUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("isher"),
@@ -64158,45 +64158,45 @@ pub static WORD_PUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_PUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUI_CHILDREN),
+static WORD_PUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nsher")],
     values: &[&["punisher"]],
     range: 5..=5,
 };
 
-static WORD_PUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUH_CHILDREN),
+static WORD_PUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sups")],
     values: &[&["pushups"]],
     range: 4..=4,
 };
 
-static WORD_PUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUE_CHILDREN),
+static WORD_PUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sdo")],
     values: &[&["pseudo"]],
     range: 3..=3,
 };
 
-static WORD_PUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUC_CHILDREN),
+static WORD_PUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hase"),
@@ -64214,12 +64214,12 @@ pub static WORD_PUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_PUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PUB_CHILDREN),
+static WORD_PUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PUB_CHILDREN),
     value: None,
 };
 
-static WORD_PUB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PUB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -64248,12 +64248,12 @@ static WORD_PUB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PUBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUBL_CHILDREN),
+static WORD_PUBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cation"),
@@ -64379,12 +64379,12 @@ pub static WORD_PUBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PUBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUBI_CHILDREN),
+static WORD_PUBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lc"),
         dictgen::InsensitiveStr::Ascii("lsh"),
@@ -64414,23 +64414,23 @@ pub static WORD_PUBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PUA_CHILDREN),
+static WORD_PUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sing")],
     values: &[&["pausing"]],
     range: 4..=4,
 };
 
-static WORD_PT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PT_CHILDREN),
+static WORD_PT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("herad"),
@@ -64470,12 +64470,12 @@ pub static WORD_PT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_PS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PS_CHILDREN),
+static WORD_PS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PS_CHILDREN),
     value: None,
 };
 
-static WORD_PS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PSA_NODE),
     None,
     Some(&WORD_PSC_NODE),
@@ -64504,12 +64504,12 @@ static WORD_PS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSY_CHILDREN),
+static WORD_PSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chadelic"),
         dictgen::InsensitiveStr::Ascii("chaitric"),
@@ -64627,12 +64627,12 @@ pub static WORD_PSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_PSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSU_CHILDREN),
+static WORD_PSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deo"),
         dictgen::InsensitiveStr::Ascii("do"),
@@ -64676,12 +64676,12 @@ pub static WORD_PSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_PSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSS_CHILDREN),
+static WORD_PSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ibility"),
@@ -64690,23 +64690,23 @@ pub static WORD_PSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_PSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSR_CHILDREN),
+static WORD_PSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ameter")],
     values: &[&["parameter"]],
     range: 6..=6,
 };
 
-static WORD_PSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSO_CHILDREN),
+static WORD_PSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -64716,12 +64716,12 @@ pub static WORD_PSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_PSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSI_CHILDREN),
+static WORD_PSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chological"),
         dictgen::InsensitiveStr::Ascii("chologically"),
@@ -64741,12 +64741,12 @@ pub static WORD_PSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_PSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSH_CHILDREN),
+static WORD_PSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("yciatric"),
         dictgen::InsensitiveStr::Ascii("yciatrist"),
@@ -64778,12 +64778,12 @@ pub static WORD_PSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=12,
 };
 
-static WORD_PSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSE_CHILDREN),
+static WORD_PSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deo"),
         dictgen::InsensitiveStr::Ascii("duo"),
@@ -64807,12 +64807,12 @@ pub static WORD_PSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_PSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSC_CHILDREN),
+static WORD_PSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("yhed"),
         dictgen::InsensitiveStr::Ascii("yhedelic"),
@@ -64846,12 +64846,12 @@ pub static WORD_PSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_PSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PSA_CHILDREN),
+static WORD_PSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -64869,12 +64869,12 @@ pub static WORD_PSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_PR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PR_CHILDREN),
+static WORD_PR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PR_CHILDREN),
     value: None,
 };
 
-static WORD_PR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRA_NODE),
     Some(&WORD_PRB_NODE),
     Some(&WORD_PRC_NODE),
@@ -64903,12 +64903,12 @@ static WORD_PR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRY_CHILDREN),
+static WORD_PRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amid"),
         dictgen::InsensitiveStr::Ascii("amids"),
@@ -64917,12 +64917,12 @@ pub static WORD_PRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_PRV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRV_CHILDREN),
+static WORD_PRV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("ide"),
@@ -64942,12 +64942,12 @@ pub static WORD_PRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_PRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRU_CHILDREN),
+static WORD_PRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chase"),
         dictgen::InsensitiveStr::Ascii("chased"),
@@ -64975,23 +64975,23 @@ pub static WORD_PRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRT_CHILDREN),
+static WORD_PRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inf")],
     values: &[&["printf"]],
     range: 3..=3,
 };
 
-static WORD_PRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRS_CHILDREN),
+static WORD_PRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -65000,12 +65000,12 @@ pub static WORD_PRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_PRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRR_CHILDREN),
+static WORD_PRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cision"),
         dictgen::InsensitiveStr::Ascii("ottypes"),
@@ -65014,12 +65014,12 @@ pub static WORD_PRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_PRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRP_CHILDREN),
+static WORD_PRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eparations"),
         dictgen::InsensitiveStr::Ascii("ose"),
@@ -65041,12 +65041,12 @@ pub static WORD_PRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_PRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRO_CHILDREN),
+static WORD_PRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRO_CHILDREN),
     value: None,
 };
 
-static WORD_PRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROA_NODE),
     Some(&WORD_PROB_NODE),
     Some(&WORD_PROC_NODE),
@@ -65075,23 +65075,23 @@ static WORD_PRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROZ_NODE),
 ];
 
-static WORD_PROZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROZ_CHILDREN),
+static WORD_PROZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["process"]],
     range: 3..=3,
 };
 
-static WORD_PROY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROY_CHILDREN),
+static WORD_PROY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -65111,12 +65111,12 @@ pub static WORD_PROY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PROX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROX_CHILDREN),
+static WORD_PROX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imty"),
         dictgen::InsensitiveStr::Ascii("yed"),
@@ -65125,12 +65125,12 @@ pub static WORD_PROX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PROV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROV_CHILDREN),
+static WORD_PROV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROV_CHILDREN),
     value: None,
 };
 
-static WORD_PROV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROVA_NODE),
     None,
     None,
@@ -65159,23 +65159,23 @@ static WORD_PROV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVS_CHILDREN),
+static WORD_PROVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ioning")],
     values: &[&["provisioning"]],
     range: 6..=6,
 };
 
-static WORD_PROVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVO_CHILDREN),
+static WORD_PROVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("active"),
         dictgen::InsensitiveStr::Ascii("catie"),
@@ -65209,12 +65209,12 @@ pub static WORD_PROVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVI_CHILDREN),
+static WORD_PROVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cative"),
         dictgen::InsensitiveStr::Ascii("cde"),
@@ -65324,12 +65324,12 @@ pub static WORD_PROVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PROVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVE_CHILDREN),
+static WORD_PROVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dd"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -65353,12 +65353,12 @@ pub static WORD_PROVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PROVD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVD_CHILDREN),
+static WORD_PROVD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -65386,12 +65386,12 @@ pub static WORD_PROVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_PROVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROVA_CHILDREN),
+static WORD_PROVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cative"),
         dictgen::InsensitiveStr::Ascii("cotive"),
@@ -65401,12 +65401,12 @@ pub static WORD_PROVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROU_CHILDREN),
+static WORD_PROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ldy"),
         dictgen::InsensitiveStr::Ascii("ncements"),
@@ -65415,12 +65415,12 @@ pub static WORD_PROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PROT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROT_CHILDREN),
+static WORD_PROT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROT_CHILDREN),
     value: None,
 };
 
-static WORD_PROT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROTA_NODE),
     None,
     Some(&WORD_PROTC_NODE),
@@ -65449,23 +65449,23 @@ static WORD_PROT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROTY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTY_CHILDREN),
+static WORD_PROTY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pted")],
     values: &[&["prototyped"]],
     range: 4..=4,
 };
 
-static WORD_PROTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTU_CHILDREN),
+static WORD_PROTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gal"),
         dictgen::InsensitiveStr::Ascii("guese"),
@@ -65474,12 +65474,12 @@ pub static WORD_PROTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_PROTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTR_CHILDREN),
+static WORD_PROTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ait"),
         dictgen::InsensitiveStr::Ascii("aits"),
@@ -65505,12 +65505,12 @@ pub static WORD_PROTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PROTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTO_CHILDREN),
+static WORD_PROTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("call"),
@@ -65594,12 +65594,12 @@ pub static WORD_PROTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PROTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTL_CHILDREN),
+static WORD_PROTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -65608,12 +65608,12 @@ pub static WORD_PROTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PROTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTI_CHILDREN),
+static WORD_PROTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -65633,34 +65633,34 @@ pub static WORD_PROTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTH_CHILDREN),
+static WORD_PROTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("setic")],
     values: &[&["prosthetic"]],
     range: 5..=5,
 };
 
-static WORD_PROTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTF_CHILDREN),
+static WORD_PROTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("olio")],
     values: &[&["portfolio"]],
     range: 4..=4,
 };
 
-static WORD_PROTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTE_CHILDREN),
+static WORD_PROTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -65750,12 +65750,12 @@ pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTC_CHILDREN),
+static WORD_PROTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ol"),
         dictgen::InsensitiveStr::Ascii("ols"),
@@ -65773,12 +65773,12 @@ pub static WORD_PROTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PROTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROTA_CHILDREN),
+static WORD_PROTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -65818,12 +65818,12 @@ pub static WORD_PROTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROS_CHILDREN),
+static WORD_PROS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cratination"),
         dictgen::InsensitiveStr::Ascii("ectued"),
@@ -65955,12 +65955,12 @@ pub static WORD_PROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PROR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROR_CHILDREN),
+static WORD_PROR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ities"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -65970,12 +65970,12 @@ pub static WORD_PROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_PROP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROP_CHILDREN),
+static WORD_PROP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROP_CHILDREN),
     value: None,
 };
 
-static WORD_PROP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROPA_NODE),
     Some(&WORD_PROPB_NODE),
     None,
@@ -66004,23 +66004,23 @@ static WORD_PROP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROPV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPV_CHILDREN),
+static WORD_PROPV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ider")],
     values: &[&["provider"]],
     range: 4..=4,
 };
 
-static WORD_PROPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPU_CHILDREN),
+static WORD_PROPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laios"),
         dictgen::InsensitiveStr::Ascii("lsing"),
@@ -66038,12 +66038,12 @@ pub static WORD_PROPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PROPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPT_CHILDREN),
+static WORD_PROPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPT_CHILDREN),
     value: Some(&["prompt"]),
 };
 
-pub static WORD_PROPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eries"),
         dictgen::InsensitiveStr::Ascii("erties"),
@@ -66059,12 +66059,12 @@ pub static WORD_PROPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPS_CHILDREN),
+static WORD_PROPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -66088,12 +66088,12 @@ pub static WORD_PROPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_PROPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPR_CHILDREN),
+static WORD_PROPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eitary"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -66167,12 +66167,12 @@ pub static WORD_PROPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PROPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPP_CHILDREN),
+static WORD_PROPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ely"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -66190,12 +66190,12 @@ pub static WORD_PROPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPO_CHILDREN),
+static WORD_PROPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agate"),
         dictgen::InsensitiveStr::Ascii("erties"),
@@ -66297,12 +66297,12 @@ pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PROPM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPM_CHILDREN),
+static WORD_PROPM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -66322,12 +66322,12 @@ pub static WORD_PROPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_PROPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPL_CHILDREN),
+static WORD_PROPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("em"),
         dictgen::InsensitiveStr::Ascii("usion"),
@@ -66336,12 +66336,12 @@ pub static WORD_PROPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PROPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPI_CHILDREN),
+static WORD_PROPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ertary"),
         dictgen::InsensitiveStr::Ascii("etary"),
@@ -66363,12 +66363,12 @@ pub static WORD_PROPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PROPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPH_CHILDREN),
+static WORD_PROPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acies"),
         dictgen::InsensitiveStr::Ascii("acy"),
@@ -66390,12 +66390,12 @@ pub static WORD_PROPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROPG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPG_CHILDREN),
+static WORD_PROPG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("ating"),
@@ -66404,12 +66404,12 @@ pub static WORD_PROPG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PROPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROPE_CHILDREN),
+static WORD_PROPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROPE_CHILDREN),
     value: None,
 };
 
-static WORD_PROPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_PROPEC_NODE),
@@ -66438,12 +66438,12 @@ static WORD_PROPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPET_CHILDREN),
+static WORD_PROPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("iies"),
@@ -66463,23 +66463,23 @@ pub static WORD_PROPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_PROPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPES_CHILDREN),
+static WORD_PROPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("terous")],
     values: &[&["preposterous"]],
     range: 6..=6,
 };
 
-static WORD_PROPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPER_CHILDREN),
+static WORD_PROPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eties"),
         dictgen::InsensitiveStr::Ascii("ety"),
@@ -66559,23 +66559,23 @@ pub static WORD_PROPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PROPEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEO_CHILDREN),
+static WORD_PROPEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("perties")],
     values: &[&["properties"]],
     range: 7..=7,
 };
 
-static WORD_PROPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEN_CHILDREN),
+static WORD_PROPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("city"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -66584,23 +66584,23 @@ pub static WORD_PROPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=4,
 };
 
-static WORD_PROPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEL_CHILDREN),
+static WORD_PROPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["properly"]],
     range: 1..=1,
 };
 
-static WORD_PROPEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEH_CHILDREN),
+static WORD_PROPEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cy"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -66610,23 +66610,23 @@ pub static WORD_PROPEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_PROPEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEG_CHILDREN),
+static WORD_PROPEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ate")],
     values: &[&["propagate"]],
     range: 3..=3,
 };
 
-static WORD_PROPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPEC_CHILDREN),
+static WORD_PROPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hies"),
         dictgen::InsensitiveStr::Ascii("hy"),
@@ -66662,23 +66662,23 @@ pub static WORD_PROPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PROPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPB_CHILDREN),
+static WORD_PROPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ably")],
     values: &[&["probably"]],
     range: 4..=4,
 };
 
-static WORD_PROPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROPA_CHILDREN),
+static WORD_PROPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilities"),
         dictgen::InsensitiveStr::Ascii("bly"),
@@ -66712,12 +66712,12 @@ pub static WORD_PROPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROO_CHILDREN),
+static WORD_PROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cecure"),
         dictgen::InsensitiveStr::Ascii("cecures"),
@@ -66791,12 +66791,12 @@ pub static WORD_PROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PRON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRON_CHILDREN),
+static WORD_PRON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRON_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nounced"),
         dictgen::InsensitiveStr::Ascii("ography"),
@@ -66854,12 +66854,12 @@ pub static WORD_PRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PROM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROM_CHILDREN),
+static WORD_PROM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROM_CHILDREN),
     value: None,
 };
 
-static WORD_PROM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROMA_NODE),
     None,
     None,
@@ -66888,12 +66888,12 @@ static WORD_PROM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMT_CHILDREN),
+static WORD_PROMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMT_CHILDREN),
     value: Some(&["prompt"]),
 };
 
-pub static WORD_PROMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -66921,23 +66921,23 @@ pub static WORD_PROMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_PROMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMS_CHILDREN),
+static WORD_PROMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icuous")],
     values: &[&["promiscuous"]],
     range: 6..=6,
 };
 
-static WORD_PROMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMP_CHILDREN),
+static WORD_PROMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lty"),
         dictgen::InsensitiveStr::Ascii("rted"),
@@ -66957,12 +66957,12 @@ pub static WORD_PROMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_PROMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMO_CHILDREN),
+static WORD_PROMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cional"),
         dictgen::InsensitiveStr::Ascii("rdials"),
@@ -66990,12 +66990,12 @@ pub static WORD_PROMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PROMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMM_CHILDREN),
+static WORD_PROMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pts"),
@@ -67004,12 +67004,12 @@ pub static WORD_PROMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PROMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMI_CHILDREN),
+static WORD_PROMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mently"),
         dictgen::InsensitiveStr::Ascii("nance"),
@@ -67061,12 +67061,12 @@ pub static WORD_PROMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PROME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROME_CHILDREN),
+static WORD_PROME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROME_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nantly"),
         dictgen::InsensitiveStr::Ascii("nently"),
@@ -67096,23 +67096,23 @@ pub static WORD_PROME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PROMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROMA_CHILDREN),
+static WORD_PROMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tory")],
     values: &[&["promontory"]],
     range: 4..=4,
 };
 
-static WORD_PROL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROL_CHILDREN),
+static WORD_PROL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ateriat"),
         dictgen::InsensitiveStr::Ascii("bems"),
@@ -67154,23 +67154,23 @@ pub static WORD_PROL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROK_CHILDREN),
+static WORD_PROK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROK_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rastination")],
     values: &[&["procrastination"]],
     range: 11..=11,
 };
 
-static WORD_PROJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROJ_CHILDREN),
+static WORD_PROJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cet"),
         dictgen::InsensitiveStr::Ascii("cets"),
@@ -67256,12 +67256,12 @@ pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROI_CHILDREN),
+static WORD_PROI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("fle"),
@@ -67281,12 +67281,12 @@ pub static WORD_PROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PROH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROH_CHILDREN),
+static WORD_PROH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abition"),
         dictgen::InsensitiveStr::Ascii("ibation"),
@@ -67350,12 +67350,12 @@ pub static WORD_PROH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PROG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROG_CHILDREN),
+static WORD_PROG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROG_CHILDREN),
     value: None,
 };
 
-static WORD_PROG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROGA_NODE),
     None,
     None,
@@ -67384,12 +67384,12 @@ static WORD_PROG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROGR_CHILDREN),
+static WORD_PROGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROGR_CHILDREN),
     value: None,
 };
 
-static WORD_PROGR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROGR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROGRA_NODE),
     None,
     None,
@@ -67418,23 +67418,23 @@ static WORD_PROGR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROGRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRS_CHILDREN),
+static WORD_PROGRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["progress"]],
     range: 1..=1,
 };
 
-static WORD_PROGRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRO_CHILDREN),
+static WORD_PROGRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("ms"),
@@ -67443,12 +67443,12 @@ pub static WORD_PROGRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_PROGRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRM_CHILDREN),
+static WORD_PROGRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -67458,12 +67458,12 @@ pub static WORD_PROGRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_PROGRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRE_CHILDREN),
+static WORD_PROGRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -67549,12 +67549,12 @@ pub static WORD_PROGRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_PROGRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGRA_CHILDREN),
+static WORD_PROGRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aming"),
         dictgen::InsensitiveStr::Ascii("ma"),
@@ -67630,23 +67630,23 @@ pub static WORD_PROGRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_PROGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGI_CHILDREN),
+static WORD_PROGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dy")],
     values: &[&["prodigy"]],
     range: 2..=2,
 };
 
-static WORD_PROGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGE_CHILDREN),
+static WORD_PROGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rssion"),
         dictgen::InsensitiveStr::Ascii("rssive"),
@@ -67674,12 +67674,12 @@ pub static WORD_PROGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROGA_CHILDREN),
+static WORD_PROGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROGA_CHILDREN),
     value: None,
 };
 
-static WORD_PROGA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROGA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -67708,12 +67708,12 @@ static WORD_PROGA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROGAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAT_CHILDREN),
+static WORD_PROGAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ators"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -67737,12 +67737,12 @@ pub static WORD_PROGAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PROGAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAR_CHILDREN),
+static WORD_PROGAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amm"),
         dictgen::InsensitiveStr::Ascii("ammability"),
@@ -67790,12 +67790,12 @@ pub static WORD_PROGAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_PROGAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAP_CHILDREN),
+static WORD_PROGAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -67819,12 +67819,12 @@ pub static WORD_PROGAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PROGAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAM_CHILDREN),
+static WORD_PROGAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAM_CHILDREN),
     value: Some(&["program"]),
 };
 
-pub static WORD_PROGAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -67870,12 +67870,12 @@ pub static WORD_PROGAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_PROGAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROGAG_CHILDREN),
+static WORD_PROGAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROGAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROGAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROGAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -67899,12 +67899,12 @@ pub static WORD_PROGAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PROF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROF_CHILDREN),
+static WORD_PROF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROF_CHILDREN),
     value: None,
 };
 
-static WORD_PROF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -67933,12 +67933,12 @@ static WORD_PROF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFU_CHILDREN),
+static WORD_PROFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ndly"),
@@ -67947,34 +67947,34 @@ pub static WORD_PROFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PROFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFT_CHILDREN),
+static WORD_PROFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iable")],
     values: &[&["profitable"]],
     range: 5..=5,
 };
 
-static WORD_PROFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFR_CHILDREN),
+static WORD_PROFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("essions")],
     values: &[&["progressions"]],
     range: 7..=7,
 };
 
-static WORD_PROFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFL_CHILDREN),
+static WORD_PROFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -67992,12 +67992,12 @@ pub static WORD_PROFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PROFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFI_CHILDREN),
+static WORD_PROFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceint"),
         dictgen::InsensitiveStr::Ascii("ciancy"),
@@ -68065,12 +68065,12 @@ pub static WORD_PROFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PROFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFF_CHILDREN),
+static WORD_PROFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esed"),
         dictgen::InsensitiveStr::Ascii("esion"),
@@ -68094,12 +68094,12 @@ pub static WORD_PROFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_PROFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROFE_CHILDREN),
+static WORD_PROFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sion"),
         dictgen::InsensitiveStr::Ascii("sional"),
@@ -68175,12 +68175,12 @@ pub static WORD_PROFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PROE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROE_CHILDREN),
+static WORD_PROE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cess"),
         dictgen::InsensitiveStr::Ascii("ceudre"),
@@ -68222,12 +68222,12 @@ pub static WORD_PROE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROD_CHILDREN),
+static WORD_PROD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceding"),
         dictgen::InsensitiveStr::Ascii("cut"),
@@ -68335,12 +68335,12 @@ pub static WORD_PROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROC_CHILDREN),
+static WORD_PROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROC_CHILDREN),
     value: None,
 };
 
-static WORD_PROC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROCA_NODE),
     None,
     Some(&WORD_PROCC_NODE),
@@ -68369,12 +68369,12 @@ static WORD_PROC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCU_CHILDREN),
+static WORD_PROCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -68408,12 +68408,12 @@ pub static WORD_PROCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PROCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCT_CHILDREN),
+static WORD_PROCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -68431,23 +68431,23 @@ pub static WORD_PROCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PROCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCS_CHILDREN),
+static WORD_PROCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sed")],
     values: &[&["processed"]],
     range: 3..=3,
 };
 
-static WORD_PROCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCR_CHILDREN),
+static WORD_PROCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ascinating"),
         dictgen::InsensitiveStr::Ascii("astenating"),
@@ -68495,12 +68495,12 @@ pub static WORD_PROCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_PROCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCO_CHILDREN),
+static WORD_PROCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("essed"),
@@ -68520,12 +68520,12 @@ pub static WORD_PROCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PROCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCL_CHILDREN),
+static WORD_PROCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aimation"),
         dictgen::InsensitiveStr::Ascii("am"),
@@ -68551,12 +68551,12 @@ pub static WORD_PROCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCI_CHILDREN),
+static WORD_PROCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -68566,12 +68566,12 @@ pub static WORD_PROCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PROCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROCE_CHILDREN),
+static WORD_PROCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROCE_CHILDREN),
     value: Some(&["price"]),
 };
 
-static WORD_PROCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROCE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_PROCEC_NODE),
@@ -68600,12 +68600,12 @@ static WORD_PROCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROCES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCES_CHILDREN),
+static WORD_PROCES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCES_CHILDREN),
     value: Some(&["process"]),
 };
 
-pub static WORD_PROCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -68681,23 +68681,23 @@ pub static WORD_PROCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_PROCEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCEN_CHILDREN),
+static WORD_PROCEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tual")],
     values: &[&["percentual"]],
     range: 4..=4,
 };
 
-static WORD_PROCEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCEL_CHILDREN),
+static WORD_PROCEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ains"),
@@ -68706,12 +68706,12 @@ pub static WORD_PROCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_PROCEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCEE_CHILDREN),
+static WORD_PROCEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deds"),
         dictgen::InsensitiveStr::Ascii("des"),
@@ -68747,12 +68747,12 @@ pub static WORD_PROCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PROCED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCED_CHILDREN),
+static WORD_PROCED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCED_CHILDREN),
     value: Some(&["proceed"]),
 };
 
-pub static WORD_PROCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("dings"),
@@ -68794,12 +68794,12 @@ pub static WORD_PROCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_PROCEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCEC_CHILDREN),
+static WORD_PROCEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("ure"),
@@ -68809,12 +68809,12 @@ pub static WORD_PROCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_PROCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCC_CHILDREN),
+static WORD_PROCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eding"),
         dictgen::InsensitiveStr::Ascii("edings"),
@@ -68852,12 +68852,12 @@ pub static WORD_PROCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PROCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROCA_CHILDREN),
+static WORD_PROCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lim"),
         dictgen::InsensitiveStr::Ascii("limed"),
@@ -68875,12 +68875,12 @@ pub static WORD_PROCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PROB_CHILDREN),
+static WORD_PROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PROB_CHILDREN),
     value: None,
 };
 
-static WORD_PROB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PROB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PROBA_NODE),
     Some(&WORD_PROBB_NODE),
     None,
@@ -68909,23 +68909,23 @@ static WORD_PROB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PROBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBO_CHILDREN),
+static WORD_PROBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bly")],
     values: &[&["probably"]],
     range: 3..=3,
 };
 
-static WORD_PROBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBL_CHILDREN),
+static WORD_PROBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("aem"),
@@ -68967,23 +68967,23 @@ pub static WORD_PROBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PROBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBI_CHILDREN),
+static WORD_PROBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lity")],
     values: &[&["probability"]],
     range: 4..=4,
 };
 
-static WORD_PROBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBE_CHILDREN),
+static WORD_PROBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lm"),
         dictgen::InsensitiveStr::Ascii("lmatic"),
@@ -69003,12 +69003,12 @@ pub static WORD_PROBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_PROBB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBB_CHILDREN),
+static WORD_PROBB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("ailities"),
@@ -69036,12 +69036,12 @@ pub static WORD_PROBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PROBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROBA_CHILDREN),
+static WORD_PROBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bably"),
         dictgen::InsensitiveStr::Ascii("balistic"),
@@ -69113,12 +69113,12 @@ pub static WORD_PROBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_PROA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PROA_CHILDREN),
+static WORD_PROA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PROA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PROA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bably"),
         dictgen::InsensitiveStr::Ascii("baly"),
@@ -69140,12 +69140,12 @@ pub static WORD_PROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRM_CHILDREN),
+static WORD_PRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itive"),
         dictgen::InsensitiveStr::Ascii("itives"),
@@ -69155,12 +69155,12 @@ pub static WORD_PRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_PRJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRJ_CHILDREN),
+static WORD_PRJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ecting"),
@@ -69178,12 +69178,12 @@ pub static WORD_PRJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRI_CHILDREN),
+static WORD_PRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRI_CHILDREN),
     value: None,
 };
 
-static WORD_PRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRIA_NODE),
     None,
     Some(&WORD_PRIC_NODE),
@@ -69212,12 +69212,12 @@ static WORD_PRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRIV_CHILDREN),
+static WORD_PRIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRIV_CHILDREN),
     value: None,
 };
 
-static WORD_PRIV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRIV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRIVA_NODE),
     None,
     Some(&WORD_PRIVC_NODE),
@@ -69246,34 +69246,34 @@ static WORD_PRIV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRIVT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVT_CHILDREN),
+static WORD_PRIVT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["private"]],
     range: 1..=1,
 };
 
-static WORD_PRIVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVO_CHILDREN),
+static WORD_PRIVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ded")],
     values: &[&["provided"]],
     range: 3..=3,
 };
 
-static WORD_PRIVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVL_CHILDREN),
+static WORD_PRIVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edge"),
         dictgen::InsensitiveStr::Ascii("ege"),
@@ -69289,12 +69289,12 @@ pub static WORD_PRIVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PRIVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVI_CHILDREN),
+static WORD_PRIVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -69374,12 +69374,12 @@ pub static WORD_PRIVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PRIVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVE_CHILDREN),
+static WORD_PRIVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laged"),
         dictgen::InsensitiveStr::Ascii("lages"),
@@ -69417,34 +69417,34 @@ pub static WORD_PRIVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PRIVD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVD_CHILDREN),
+static WORD_PRIVD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["provide"]],
     range: 1..=1,
 };
 
-static WORD_PRIVC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVC_CHILDREN),
+static WORD_PRIVC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["privacy"]],
     range: 1..=1,
 };
 
-static WORD_PRIVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIVA_CHILDREN),
+static WORD_PRIVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ledge"),
         dictgen::InsensitiveStr::Ascii("lege"),
@@ -69466,23 +69466,23 @@ pub static WORD_PRIVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PRIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIT_CHILDREN),
+static WORD_PRIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["printing"]],
     range: 3..=3,
 };
 
-static WORD_PRIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIS_CHILDREN),
+static WORD_PRIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIS_CHILDREN),
     value: Some(&["prise", "prism"]),
 };
 
-pub static WORD_PRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("itne"),
@@ -69492,12 +69492,12 @@ pub static WORD_PRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PRIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIR_CHILDREN),
+static WORD_PRIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ity"),
         dictgen::InsensitiveStr::Ascii("oity"),
@@ -69513,12 +69513,12 @@ pub static WORD_PRIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PRIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIP_CHILDREN),
+static WORD_PRIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heral"),
         dictgen::InsensitiveStr::Ascii("oritzes"),
@@ -69527,12 +69527,12 @@ pub static WORD_PRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PRIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIO_CHILDREN),
+static WORD_PRIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irties"),
         dictgen::InsensitiveStr::Ascii("irty"),
@@ -69604,12 +69604,12 @@ pub static WORD_PRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PRIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIN_CHILDREN),
+static WORD_PRIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cepals"),
         dictgen::InsensitiveStr::Ascii("ceple"),
@@ -69691,12 +69691,12 @@ pub static WORD_PRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PRIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIM_CHILDREN),
+static WORD_PRIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aires"),
         dictgen::InsensitiveStr::Ascii("airly"),
@@ -69760,12 +69760,12 @@ pub static WORD_PRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PRIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIE_CHILDREN),
+static WORD_PRIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mere"),
         dictgen::InsensitiveStr::Ascii("stes"),
@@ -69781,12 +69781,12 @@ pub static WORD_PRIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PRIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIC_CHILDREN),
+static WORD_PRIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inpals"),
         dictgen::InsensitiveStr::Ascii("ipal"),
@@ -69804,12 +69804,12 @@ pub static WORD_PRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PRIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRIA_CHILDREN),
+static WORD_PRIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sed"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -69819,23 +69819,23 @@ pub static WORD_PRIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRG_CHILDREN),
+static WORD_PRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ram")],
     values: &[&["program"]],
     range: 3..=3,
 };
 
-static WORD_PRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRF_CHILDREN),
+static WORD_PRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erable"),
@@ -69853,12 +69853,12 @@ pub static WORD_PRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_PRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRE_CHILDREN),
+static WORD_PRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRE_CHILDREN),
     value: None,
 };
 
-static WORD_PRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREA_NODE),
     Some(&WORD_PREB_NODE),
     Some(&WORD_PREC_NODE),
@@ -69887,23 +69887,23 @@ static WORD_PRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREZ_NODE),
 ];
 
-static WORD_PREZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREZ_CHILDREN),
+static WORD_PREZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("idential")],
     values: &[&["presidential"]],
     range: 8..=8,
 };
 
-static WORD_PREX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREX_CHILDREN),
+static WORD_PREX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isting"),
         dictgen::InsensitiveStr::Ascii("ixed"),
@@ -69912,23 +69912,23 @@ pub static WORD_PREX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PREW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREW_CHILDREN),
+static WORD_PREW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("view")],
     values: &[&["preview"]],
     range: 4..=4,
 };
 
-static WORD_PREV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PREV_CHILDREN),
+static WORD_PREV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PREV_CHILDREN),
     value: None,
 };
 
-static WORD_PREV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PREV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREVA_NODE),
     None,
     None,
@@ -69957,12 +69957,12 @@ static WORD_PREV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PREVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREVO_CHILDREN),
+static WORD_PREVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ius"),
         dictgen::InsensitiveStr::Ascii("iusly"),
@@ -69980,12 +69980,12 @@ pub static WORD_PREVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PREVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREVI_CHILDREN),
+static WORD_PREVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aling"),
@@ -70049,12 +70049,12 @@ pub static WORD_PREVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PREVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREVE_CHILDREN),
+static WORD_PREVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iw"),
         dictgen::InsensitiveStr::Ascii("iwed"),
@@ -70118,12 +70118,12 @@ pub static WORD_PREVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PREVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREVA_CHILDREN),
+static WORD_PREVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilaing"),
         dictgen::InsensitiveStr::Ascii("illing"),
@@ -70141,12 +70141,12 @@ pub static WORD_PREVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRET_CHILDREN),
+static WORD_PRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRET_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ador"),
         dictgen::InsensitiveStr::Ascii("aining"),
@@ -70204,12 +70204,12 @@ pub static WORD_PRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRES_CHILDREN),
+static WORD_PRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRES_CHILDREN),
     value: None,
 };
 
-static WORD_PRES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRESA_NODE),
     Some(&WORD_PRESB_NODE),
     Some(&WORD_PRESC_NODE),
@@ -70238,12 +70238,12 @@ static WORD_PRES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRESU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESU_CHILDREN),
+static WORD_PRESU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -70293,12 +70293,12 @@ pub static WORD_PRESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PREST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREST_CHILDREN),
+static WORD_PREST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREST_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egious"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -70334,12 +70334,12 @@ pub static WORD_PREST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PRESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESS_CHILDREN),
+static WORD_PRESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -70375,12 +70375,12 @@ pub static WORD_PRESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PRESR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESR_CHILDREN),
+static WORD_PRESR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciption"),
         dictgen::InsensitiveStr::Ascii("eved"),
@@ -70390,12 +70390,12 @@ pub static WORD_PRESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PRESP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESP_CHILDREN),
+static WORD_PRESP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ective"),
         dictgen::InsensitiveStr::Ascii("ectives"),
@@ -70404,12 +70404,12 @@ pub static WORD_PRESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_PRESO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESO_CHILDREN),
+static WORD_PRESO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mption"),
         dictgen::InsensitiveStr::Ascii("nalized"),
@@ -70427,12 +70427,12 @@ pub static WORD_PRESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PRESN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESN_CHILDREN),
+static WORD_PRESN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etation"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -70448,12 +70448,12 @@ pub static WORD_PRESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PRESM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESM_CHILDREN),
+static WORD_PRESM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("issions"),
         dictgen::InsensitiveStr::Ascii("uably"),
@@ -70462,12 +70462,12 @@ pub static WORD_PRESM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PRESI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESI_CHILDREN),
+static WORD_PRESI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cely"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -70539,12 +70539,12 @@ pub static WORD_PRESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PRESH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESH_CHILDREN),
+static WORD_PRESH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("is"),
         dictgen::InsensitiveStr::Ascii("isly"),
@@ -70560,12 +70560,12 @@ pub static WORD_PRESH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PRESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESE_CHILDREN),
+static WORD_PRESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aring"),
         dictgen::InsensitiveStr::Ascii("arvation"),
@@ -70689,12 +70689,12 @@ pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PRESC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESC_CHILDREN),
+static WORD_PRESC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edence"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -70744,12 +70744,12 @@ pub static WORD_PRESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PRESB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESB_CHILDREN),
+static WORD_PRESB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aterian"),
         dictgen::InsensitiveStr::Ascii("aterians"),
@@ -70765,23 +70765,23 @@ pub static WORD_PRESB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_PRESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRESA_CHILDREN),
+static WORD_PRESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nce")],
     values: &[&["presence"]],
     range: 3..=3,
 };
 
-static WORD_PRER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRER_CHILDREN),
+static WORD_PRER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRER_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("equesit"),
         dictgen::InsensitiveStr::Ascii("equesite"),
@@ -70827,12 +70827,12 @@ pub static WORD_PRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PREQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREQ_CHILDREN),
+static WORD_PREQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euls"),
         dictgen::InsensitiveStr::Ascii("uisite"),
@@ -70848,12 +70848,12 @@ pub static WORD_PREQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREP_CHILDREN),
+static WORD_PREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("air"),
         dictgen::InsensitiveStr::Ascii("aird"),
@@ -70987,12 +70987,12 @@ pub static WORD_PREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_PREO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREO_CHILDREN),
+static WORD_PREO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cess"),
         dictgen::InsensitiveStr::Ascii("cessing"),
@@ -71026,12 +71026,12 @@ pub static WORD_PREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_PREM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREM_CHILDREN),
+static WORD_PREM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anent"),
         dictgen::InsensitiveStr::Ascii("anently"),
@@ -71103,12 +71103,12 @@ pub static WORD_PREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_PREL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREL_CHILDREN),
+static WORD_PREL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayed"),
         dictgen::InsensitiveStr::Ascii("ease"),
@@ -71134,12 +71134,12 @@ pub static WORD_PREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_PREJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREJ_CHILDREN),
+static WORD_PREJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -71189,12 +71189,12 @@ pub static WORD_PREJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PREI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREI_CHILDREN),
+static WORD_PREI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dction"),
         dictgen::InsensitiveStr::Ascii("mer"),
@@ -71246,23 +71246,23 @@ pub static WORD_PREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_PREH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREH_CHILDREN),
+static WORD_PREH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aps")],
     values: &[&["perhaps"]],
     range: 3..=3,
 };
 
-static WORD_PREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREG_CHILDREN),
+static WORD_PREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancies"),
         dictgen::InsensitiveStr::Ascii("ancy"),
@@ -71288,12 +71288,12 @@ pub static WORD_PREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PREF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PREF_CHILDREN),
+static WORD_PREF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PREF_CHILDREN),
     value: None,
 };
 
-static WORD_PREF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PREF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREFA_NODE),
     None,
     None,
@@ -71322,12 +71322,12 @@ static WORD_PREF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PREFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFR_CHILDREN),
+static WORD_PREFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ences"),
@@ -71336,12 +71336,12 @@ pub static WORD_PREFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PREFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFO_CHILDREN),
+static WORD_PREFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rmance"),
         dictgen::InsensitiveStr::Ascii("rmances"),
@@ -71359,12 +71359,12 @@ pub static WORD_PREFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PREFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFI_CHILDREN),
+static WORD_PREFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ces"),
         dictgen::InsensitiveStr::Ascii("ciency"),
@@ -71392,12 +71392,12 @@ pub static WORD_PREFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PREFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFF_CHILDREN),
+static WORD_PREFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erable"),
@@ -71421,12 +71421,12 @@ pub static WORD_PREFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PREFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFE_CHILDREN),
+static WORD_PREFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctches"),
         dictgen::InsensitiveStr::Ascii("cth"),
@@ -71548,12 +71548,12 @@ pub static WORD_PREFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_PREFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREFA_CHILDREN),
+static WORD_PREFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rable"),
         dictgen::InsensitiveStr::Ascii("rably"),
@@ -71562,12 +71562,12 @@ pub static WORD_PREFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_PREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREE_CHILDREN),
+static WORD_PREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceding"),
         dictgen::InsensitiveStr::Ascii("mptable"),
@@ -71587,12 +71587,12 @@ pub static WORD_PREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PRED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRED_CHILDREN),
+static WORD_PRED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRED_CHILDREN),
     value: None,
 };
 
-static WORD_PRED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRED_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PREDA_NODE),
     None,
     None,
@@ -71621,12 +71621,12 @@ static WORD_PRED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PREDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDU_CHILDREN),
+static WORD_PREDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -71644,12 +71644,12 @@ pub static WORD_PREDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PREDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDO_CHILDREN),
+static WORD_PREDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessor"),
         dictgen::InsensitiveStr::Ascii("cessors"),
@@ -71675,12 +71675,12 @@ pub static WORD_PREDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_PREDJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDJ_CHILDREN),
+static WORD_PREDJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uice"),
         dictgen::InsensitiveStr::Ascii("uiced"),
@@ -71690,12 +71690,12 @@ pub static WORD_PREDJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PREDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDI_CHILDREN),
+static WORD_PREDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cat"),
         dictgen::InsensitiveStr::Ascii("catble"),
@@ -71763,23 +71763,23 @@ pub static WORD_PREDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PREDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDF_CHILDREN),
+static WORD_PREDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ined")],
     values: &[&["predefined"]],
     range: 4..=4,
 };
 
-static WORD_PREDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDE_CHILDREN),
+static WORD_PREDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cated"),
         dictgen::InsensitiveStr::Ascii("ccesors"),
@@ -71845,12 +71845,12 @@ pub static WORD_PREDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_PREDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREDA_CHILDREN),
+static WORD_PREDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessor"),
         dictgen::InsensitiveStr::Ascii("cessors"),
@@ -71860,12 +71860,12 @@ pub static WORD_PREDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PREC_CHILDREN),
+static WORD_PREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PREC_CHILDREN),
     value: None,
 };
 
-static WORD_PREC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PREC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRECA_NODE),
     None,
     Some(&WORD_PRECC_NODE),
@@ -71894,12 +71894,12 @@ static WORD_PREC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECU_CHILDREN),
+static WORD_PRECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -71929,12 +71929,12 @@ pub static WORD_PRECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PRECS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECS_CHILDREN),
+static WORD_PRECS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -71943,23 +71943,23 @@ pub static WORD_PRECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PRECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECR_CHILDREN),
+static WORD_PRECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("astination")],
     values: &[&["procrastination"]],
     range: 10..=10,
 };
 
-static WORD_PRECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECO_CHILDREN),
+static WORD_PRECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("miled"),
         dictgen::InsensitiveStr::Ascii("mupte"),
@@ -72005,12 +72005,12 @@ pub static WORD_PRECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_PRECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECI_CHILDREN),
+static WORD_PRECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -72052,12 +72052,12 @@ pub static WORD_PRECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PRECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECE_CHILDREN),
+static WORD_PRECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessor"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -72145,34 +72145,34 @@ pub static WORD_PRECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PRECD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECD_CHILDREN),
+static WORD_PRECD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["preceding"]],
     range: 3..=3,
 };
 
-static WORD_PRECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECC_CHILDREN),
+static WORD_PRECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eding")],
     values: &[&["preceding"]],
     range: 5..=5,
 };
 
-static WORD_PRECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRECA_CHILDREN),
+static WORD_PRECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cheed"),
         dictgen::InsensitiveStr::Ascii("lulated"),
@@ -72192,23 +72192,23 @@ pub static WORD_PRECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PREB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREB_CHILDREN),
+static WORD_PREB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ious")],
     values: &[&["previous"]],
     range: 4..=4,
 };
 
-static WORD_PREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PREA_CHILDREN),
+static WORD_PREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dtor"),
         dictgen::InsensitiveStr::Ascii("dtors"),
@@ -72246,12 +72246,12 @@ pub static WORD_PREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PRD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRD_CHILDREN),
+static WORD_PRD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pagate"),
         dictgen::InsensitiveStr::Ascii("pagated"),
@@ -72275,12 +72275,12 @@ pub static WORD_PRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_PRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRC_CHILDREN),
+static WORD_PRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edure"),
         dictgen::InsensitiveStr::Ascii("eeded"),
@@ -72310,23 +72310,23 @@ pub static WORD_PRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRB_CHILDREN),
+static WORD_PRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lem")],
     values: &[&["problem"]],
     range: 3..=3,
 };
 
-static WORD_PRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PRA_CHILDREN),
+static WORD_PRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PRA_CHILDREN),
     value: None,
 };
 
-static WORD_PRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PRAA_NODE),
     Some(&WORD_PRAB_NODE),
     Some(&WORD_PRAC_NODE),
@@ -72355,12 +72355,12 @@ static WORD_PRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PRAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAY_CHILDREN),
+static WORD_PRAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ries"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -72370,12 +72370,12 @@ pub static WORD_PRAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAT_CHILDREN),
+static WORD_PRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cise"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -72399,12 +72399,12 @@ pub static WORD_PRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PRAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAS_CHILDREN),
+static WORD_PRAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -72414,12 +72414,12 @@ pub static WORD_PRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PRAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAR_CHILDREN),
+static WORD_PRAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ameter"),
         dictgen::InsensitiveStr::Ascii("ameters"),
@@ -72430,12 +72430,12 @@ pub static WORD_PRAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAM_CHILDREN),
+static WORD_PRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ater"),
         dictgen::InsensitiveStr::Ascii("eter"),
@@ -72445,12 +72445,12 @@ pub static WORD_PRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAI_CHILDREN),
+static WORD_PRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ry"),
         dictgen::InsensitiveStr::Ascii("sse"),
@@ -72459,12 +72459,12 @@ pub static WORD_PRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAG_CHILDREN),
+static WORD_PRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("amtic"),
@@ -72474,23 +72474,23 @@ pub static WORD_PRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAE_CHILDREN),
+static WORD_PRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fix")],
     values: &[&["prefix"]],
     range: 3..=3,
 };
 
-static WORD_PRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAC_CHILDREN),
+static WORD_PRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itcal"),
         dictgen::InsensitiveStr::Ascii("itcally"),
@@ -72568,12 +72568,12 @@ pub static WORD_PRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_PRAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAB_CHILDREN),
+static WORD_PRAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -72583,12 +72583,12 @@ pub static WORD_PRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PRAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PRAA_CHILDREN),
+static WORD_PRAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PRAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PRAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PRAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meter"),
         dictgen::InsensitiveStr::Ascii("meters"),
@@ -72597,12 +72597,12 @@ pub static WORD_PRAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PP_CHILDREN),
+static WORD_PP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("check"),
         dictgen::InsensitiveStr::Ascii("eline"),
@@ -72626,12 +72626,12 @@ pub static WORD_PP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_PO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PO_CHILDREN),
+static WORD_PO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PO_CHILDREN),
     value: None,
 };
 
-static WORD_PO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_POB_NODE),
     Some(&WORD_POC_NODE),
@@ -72660,12 +72660,12 @@ static WORD_PO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_POZ_NODE),
 ];
 
-static WORD_POZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POZ_CHILDREN),
+static WORD_POZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_POZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itive"),
         dictgen::InsensitiveStr::Ascii("itively"),
@@ -72675,12 +72675,12 @@ pub static WORD_POZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_POY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POY_CHILDREN),
+static WORD_POY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POY_CHILDREN),
     value: None,
 };
 
-pub static WORD_POY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lgon"),
         dictgen::InsensitiveStr::Ascii("lmer"),
@@ -72689,12 +72689,12 @@ pub static WORD_POY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_POW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POW_CHILDREN),
+static WORD_POW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POW_CHILDREN),
     value: None,
 };
 
-pub static WORD_POW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("derade"),
         dictgen::InsensitiveStr::Ascii("derd"),
@@ -72750,12 +72750,12 @@ pub static WORD_POW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_POV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POV_CHILDREN),
+static WORD_POV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POV_CHILDREN),
     value: None,
 };
 
-pub static WORD_POV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erful"),
         dictgen::InsensitiveStr::Ascii("ided"),
@@ -72764,12 +72764,12 @@ pub static WORD_POV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_POU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POU_CHILDREN),
+static WORD_POU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POU_CHILDREN),
     value: None,
 };
 
-pub static WORD_POU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("int"),
         dictgen::InsensitiveStr::Ascii("late"),
@@ -72789,12 +72789,12 @@ pub static WORD_POU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_POT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POT_CHILDREN),
+static WORD_POT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POT_CHILDREN),
     value: None,
 };
 
-pub static WORD_POT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atoe"),
         dictgen::InsensitiveStr::Ascii("atos"),
@@ -72866,12 +72866,12 @@ pub static WORD_POT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_POS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POS_CHILDREN),
+static WORD_POS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POS_CHILDREN),
     value: None,
 };
 
-static WORD_POS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_POSA_NODE),
     None,
     None,
@@ -72900,12 +72900,12 @@ static WORD_POS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POST_CHILDREN),
+static WORD_POST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POST_CHILDREN),
     value: None,
 };
 
-pub static WORD_POST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("condtion"),
         dictgen::InsensitiveStr::Ascii("condtions"),
@@ -72981,12 +72981,12 @@ pub static WORD_POST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_POSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POSS_CHILDREN),
+static WORD_POSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POSS_CHILDREN),
     value: None,
 };
 
-static WORD_POSS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POSS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_POSSA_NODE),
     Some(&WORD_POSSB_NODE),
     None,
@@ -73015,12 +73015,12 @@ static WORD_POSS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POSSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSS_CHILDREN),
+static WORD_POSSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ible"),
         dictgen::InsensitiveStr::Ascii("ibly"),
@@ -73029,12 +73029,12 @@ pub static WORD_POSSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_POSSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSO_CHILDREN),
+static WORD_POSSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bily"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -73044,12 +73044,12 @@ pub static WORD_POSSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_POSSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSI_CHILDREN),
+static WORD_POSSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("bbe"),
@@ -73125,12 +73125,12 @@ pub static WORD_POSSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_POSSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSE_CHILDREN),
+static WORD_POSSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ses"),
         dictgen::InsensitiveStr::Ascii("sess"),
@@ -73168,12 +73168,12 @@ pub static WORD_POSSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_POSSB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSB_CHILDREN),
+static WORD_POSSB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSB_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ile"),
         dictgen::InsensitiveStr::Ascii("ily"),
@@ -73189,12 +73189,12 @@ pub static WORD_POSSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_POSSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSSA_CHILDREN),
+static WORD_POSSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilites"),
         dictgen::InsensitiveStr::Ascii("bilities"),
@@ -73216,12 +73216,12 @@ pub static WORD_POSSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_POSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSP_CHILDREN),
+static WORD_POSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("one"),
         dictgen::InsensitiveStr::Ascii("oned"),
@@ -73231,23 +73231,23 @@ pub static WORD_POSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_POSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSO_CHILDREN),
+static WORD_POSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["position"]],
     range: 4..=4,
 };
 
-static WORD_POSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POSI_CHILDREN),
+static WORD_POSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POSI_CHILDREN),
     value: None,
 };
 
-static WORD_POSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POSI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_POSIB_NODE),
     Some(&WORD_POSIC_NODE),
@@ -73276,12 +73276,12 @@ static WORD_POSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POSIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIT_CHILDREN),
+static WORD_POSIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("evely"),
         dictgen::InsensitiveStr::Ascii("ioing"),
@@ -73375,12 +73375,12 @@ pub static WORD_POSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_POSIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIS_CHILDREN),
+static WORD_POSIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("ition"),
@@ -73398,12 +73398,12 @@ pub static WORD_POSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_POSIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIO_CHILDREN),
+static WORD_POSIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -73419,12 +73419,12 @@ pub static WORD_POSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_POSII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSII_CHILDREN),
+static WORD_POSII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSII_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tive"),
         dictgen::InsensitiveStr::Ascii("tives"),
@@ -73440,12 +73440,12 @@ pub static WORD_POSII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_POSIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIF_CHILDREN),
+static WORD_POSIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -73454,23 +73454,23 @@ pub static WORD_POSIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_POSIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIC_CHILDREN),
+static WORD_POSIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ional")],
     values: &[&["positional"]],
     range: 5..=5,
 };
 
-static WORD_POSIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSIB_CHILDREN),
+static WORD_POSIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilities"),
         dictgen::InsensitiveStr::Ascii("ility"),
@@ -73490,12 +73490,12 @@ pub static WORD_POSIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_POSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSE_CHILDREN),
+static WORD_POSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esions"),
         dictgen::InsensitiveStr::Ascii("ss"),
@@ -73517,12 +73517,12 @@ pub static WORD_POSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_POSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POSA_CHILDREN),
+static WORD_POSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_POSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tive"),
         dictgen::InsensitiveStr::Ascii("tives"),
@@ -73532,12 +73532,12 @@ pub static WORD_POSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_POR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POR_CHILDREN),
+static WORD_POR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POR_CHILDREN),
     value: None,
 };
 
-static WORD_POR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PORA_NODE),
     Some(&WORD_PORB_NODE),
     Some(&WORD_PORC_NODE),
@@ -73566,12 +73566,12 @@ static WORD_POR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PORV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORV_CHILDREN),
+static WORD_PORV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -73601,12 +73601,12 @@ pub static WORD_PORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_PORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORT_CHILDREN),
+static WORD_PORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abel"),
         dictgen::InsensitiveStr::Ascii("abillity"),
@@ -73694,12 +73694,12 @@ pub static WORD_PORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PORS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORS_CHILDREN),
+static WORD_PORS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alin"),
         dictgen::InsensitiveStr::Ascii("han"),
@@ -73709,12 +73709,12 @@ pub static WORD_PORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PORP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORP_CHILDREN),
+static WORD_PORP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erties"),
         dictgen::InsensitiveStr::Ascii("erty"),
@@ -73742,12 +73742,12 @@ pub static WORD_PORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_PORO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORO_CHILDREN),
+static WORD_PORO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tocol"),
         dictgen::InsensitiveStr::Ascii("tocols"),
@@ -73756,12 +73756,12 @@ pub static WORD_PORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORN_CHILDREN),
+static WORD_PORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agraphy"),
         dictgen::InsensitiveStr::Ascii("ograghy"),
@@ -73789,34 +73789,34 @@ pub static WORD_PORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_PORM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORM_CHILDREN),
+static WORD_PORM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etheus")],
     values: &[&["prometheus"]],
     range: 6..=6,
 };
 
-static WORD_PORL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORL_CHILDREN),
+static WORD_PORL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etariat")],
     values: &[&["proletariat"]],
     range: 7..=7,
 };
 
-static WORD_PORJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORJ_CHILDREN),
+static WORD_PORJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ectiles"),
@@ -73832,12 +73832,12 @@ pub static WORD_PORJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORI_CHILDREN),
+static WORD_PORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("feral"),
         dictgen::InsensitiveStr::Ascii("od"),
@@ -73846,12 +73846,12 @@ pub static WORD_PORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORG_CHILDREN),
+static WORD_PORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ram"),
         dictgen::InsensitiveStr::Ascii("ramme"),
@@ -73871,12 +73871,12 @@ pub static WORD_PORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORF_CHILDREN),
+static WORD_PORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("olio"),
         dictgen::InsensitiveStr::Ascii("tolio"),
@@ -73885,34 +73885,34 @@ pub static WORD_PORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORE_CHILDREN),
+static WORD_PORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("clain")],
     values: &[&["porcelain"]],
     range: 5..=5,
 };
 
-static WORD_PORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORD_CHILDREN),
+static WORD_PORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uct")],
     values: &[&["product"]],
     range: 3..=3,
 };
 
-static WORD_PORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORC_CHILDREN),
+static WORD_PORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elan"),
         dictgen::InsensitiveStr::Ascii("elian"),
@@ -73938,12 +73938,12 @@ pub static WORD_PORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PORB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORB_CHILDREN),
+static WORD_PORB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("lem"),
@@ -73953,23 +73953,23 @@ pub static WORD_PORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PORA_CHILDREN),
+static WORD_PORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lized")],
     values: &[&["polarized"]],
     range: 5..=5,
 };
 
-static WORD_POP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POP_CHILDREN),
+static WORD_POP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POP_CHILDREN),
     value: None,
 };
 
-pub static WORD_POP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eree"),
@@ -74077,12 +74077,12 @@ pub static WORD_POP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_POO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POO_CHILDREN),
+static WORD_POO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("int"),
         dictgen::InsensitiveStr::Ascii("inted"),
@@ -74104,12 +74104,12 @@ pub static WORD_POO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_PON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PON_CHILDREN),
+static WORD_PON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PON_CHILDREN),
     value: None,
 };
 
-pub static WORD_PON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("int"),
         dictgen::InsensitiveStr::Ascii("inted"),
@@ -74151,12 +74151,12 @@ pub static WORD_PON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_POM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POM_CHILDREN),
+static WORD_POM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POM_CHILDREN),
     value: None,
 };
 
-pub static WORD_POM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egranite"),
         dictgen::InsensitiveStr::Ascii("egrenate"),
@@ -74172,12 +74172,12 @@ pub static WORD_POM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_POL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POL_CHILDREN),
+static WORD_POL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POL_CHILDREN),
     value: None,
 };
 
-static WORD_POL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_POLA_NODE),
     None,
     Some(&WORD_POLC_NODE),
@@ -74206,12 +74206,12 @@ static WORD_POL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLY_CHILDREN),
+static WORD_POLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("edral"),
@@ -74263,12 +74263,12 @@ pub static WORD_POLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_POLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLU_CHILDREN),
+static WORD_POLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("late"),
         dictgen::InsensitiveStr::Ascii("lated"),
@@ -74294,12 +74294,12 @@ pub static WORD_POLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_POLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLT_CHILDREN),
+static WORD_POLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -74317,23 +74317,23 @@ pub static WORD_POLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_POLP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLP_CHILDREN),
+static WORD_POLP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLP_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ulate")],
     values: &[&["populate"]],
     range: 5..=5,
 };
 
-static WORD_POLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLO_CHILDREN),
+static WORD_POLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cies"),
         dictgen::InsensitiveStr::Ascii("cy"),
@@ -74359,12 +74359,12 @@ pub static WORD_POLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_POLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLL_CHILDREN),
+static WORD_POLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enate"),
         dictgen::InsensitiveStr::Ascii("try"),
@@ -74373,12 +74373,12 @@ pub static WORD_POLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_POLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLI_CHILDREN),
+static WORD_POLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("cally"),
@@ -74470,12 +74470,12 @@ pub static WORD_POLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_POLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLG_CHILDREN),
+static WORD_POLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("ons"),
@@ -74486,12 +74486,12 @@ pub static WORD_POLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_POLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLC_CHILDREN),
+static WORD_POLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("iy"),
@@ -74501,34 +74501,34 @@ pub static WORD_POLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_POLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POLA_CHILDREN),
+static WORD_POLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_POLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("riy")],
     values: &[&["polarity"]],
     range: 3..=3,
 };
 
-static WORD_POK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POK_CHILDREN),
+static WORD_POK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POK_CHILDREN),
     value: None,
 };
 
-pub static WORD_POK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["pocket"]],
     range: 2..=2,
 };
 
-static WORD_POJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POJ_CHILDREN),
+static WORD_POJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_POJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ecting"),
@@ -74558,12 +74558,12 @@ pub static WORD_POJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_POI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_POI_CHILDREN),
+static WORD_POI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_POI_CHILDREN),
     value: None,
 };
 
-static WORD_POI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_POI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_POIC_NODE),
@@ -74592,23 +74592,23 @@ static WORD_POI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_POIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIU_CHILDREN),
+static WORD_POIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nter")],
     values: &[&["pointer"]],
     range: 4..=4,
 };
 
-static WORD_POIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIT_CHILDREN),
+static WORD_POIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIT_CHILDREN),
     value: Some(&["point"]),
 };
 
-pub static WORD_POIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -74650,12 +74650,12 @@ pub static WORD_POIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_POIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIS_CHILDREN),
+static WORD_POIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ioning"),
@@ -74703,12 +74703,12 @@ pub static WORD_POIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_POIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIN_CHILDREN),
+static WORD_POIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIN_CHILDREN),
     value: Some(&["point"]),
 };
 
-pub static WORD_POIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dcloud"),
@@ -74756,34 +74756,34 @@ pub static WORD_POIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_POIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIM_CHILDREN),
+static WORD_POIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["point"]],
     range: 1..=1,
 };
 
-static WORD_POIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIL_CHILDREN),
+static WORD_POIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cy")],
     values: &[&["policy"]],
     range: 2..=2,
 };
 
-static WORD_POII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POII_CHILDREN),
+static WORD_POII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POII_CHILDREN),
     value: None,
 };
 
-pub static WORD_POII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("nter"),
@@ -74793,23 +74793,23 @@ pub static WORD_POII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_POIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIG_CHILDREN),
+static WORD_POIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nat")],
     values: &[&["poignant"]],
     range: 3..=3,
 };
 
-static WORD_POIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POIC_CHILDREN),
+static WORD_POIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_POIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -74818,23 +74818,23 @@ pub static WORD_POIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_POG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POG_CHILDREN),
+static WORD_POG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POG_CHILDREN),
     value: None,
 };
 
-pub static WORD_POG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ress")],
     values: &[&["progress"]],
     range: 4..=4,
 };
 
-static WORD_POE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POE_CHILDREN),
+static WORD_POE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POE_CHILDREN),
     value: None,
 };
 
-pub static WORD_POE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nis"),
         dictgen::InsensitiveStr::Ascii("ntial"),
@@ -74866,12 +74866,12 @@ pub static WORD_POE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_POD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POD_CHILDREN),
+static WORD_POD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POD_CHILDREN),
     value: None,
 };
 
-pub static WORD_POD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emso"),
         dictgen::InsensitiveStr::Ascii("fie"),
@@ -74882,12 +74882,12 @@ pub static WORD_POD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_POC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POC_CHILDREN),
+static WORD_POC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POC_CHILDREN),
     value: None,
 };
 
-pub static WORD_POC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("essed"),
@@ -74901,12 +74901,12 @@ pub static WORD_POC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_POB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_POB_CHILDREN),
+static WORD_POB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_POB_CHILDREN),
     value: None,
 };
 
-pub static WORD_POB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_POB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("ular"),
@@ -74916,23 +74916,23 @@ pub static WORD_POB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_PN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PN_CHILDREN),
+static WORD_PN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PN_CHILDREN),
     value: Some(&["on"]),
 };
 
-pub static WORD_PN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atheon")],
     values: &[&["pantheon"]],
     range: 6..=6,
 };
 
-static WORD_PL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PL_CHILDREN),
+static WORD_PL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PL_CHILDREN),
     value: None,
 };
 
-static WORD_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PLA_NODE),
     None,
     Some(&WORD_PLC_NODE),
@@ -74961,23 +74961,23 @@ static WORD_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLY_CHILDREN),
+static WORD_PLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("otropy")],
     values: &[&["pleiotropy"]],
     range: 6..=6,
 };
 
-static WORD_PLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLU_CHILDREN),
+static WORD_PLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gable"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -75005,12 +75005,12 @@ pub static WORD_PLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_PLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLT_CHILDREN),
+static WORD_PLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("forms"),
@@ -75019,12 +75019,12 @@ pub static WORD_PLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_PLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLO_CHILDREN),
+static WORD_PLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arized"),
         dictgen::InsensitiveStr::Ascii("retariat"),
@@ -75050,23 +75050,23 @@ pub static WORD_PLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_PLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLL_CHILDREN),
+static WORD_PLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atforms")],
     values: &[&["platforms"]],
     range: 7..=7,
 };
 
-static WORD_PLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLI_CHILDREN),
+static WORD_PLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -75076,23 +75076,23 @@ pub static WORD_PLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_PLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLG_CHILDREN),
+static WORD_PLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uin")],
     values: &[&["plugin"]],
     range: 3..=3,
 };
 
-static WORD_PLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLE_CHILDREN),
+static WORD_PLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aase"),
         dictgen::InsensitiveStr::Ascii("ace"),
@@ -75158,12 +75158,12 @@ pub static WORD_PLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_PLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLC_CHILDREN),
+static WORD_PLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aebo"),
@@ -75191,12 +75191,12 @@ pub static WORD_PLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PLA_CHILDREN),
+static WORD_PLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PLA_CHILDREN),
     value: None,
 };
 
-static WORD_PLA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PLA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_PLAB_NODE),
     Some(&WORD_PLAC_NODE),
@@ -75225,12 +75225,12 @@ static WORD_PLA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PLAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAY_CHILDREN),
+static WORD_PLAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("around"),
@@ -75318,12 +75318,12 @@ pub static WORD_PLAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_PLAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAU_CHILDREN),
+static WORD_PLAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sability"),
         dictgen::InsensitiveStr::Ascii("sable"),
@@ -75343,12 +75343,12 @@ pub static WORD_PLAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_PLAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAT_CHILDREN),
+static WORD_PLAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeu"),
         dictgen::InsensitiveStr::Ascii("eu"),
@@ -75446,12 +75446,12 @@ pub static WORD_PLAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PLAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAS_CHILDREN),
+static WORD_PLAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAS_CHILDREN),
     value: Some(&["plays"]),
 };
 
-pub static WORD_PLAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -75485,12 +75485,12 @@ pub static WORD_PLAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_PLAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAR_CHILDREN),
+static WORD_PLAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("former"),
@@ -75499,12 +75499,12 @@ pub static WORD_PLAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PLAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAN_CHILDREN),
+static WORD_PLAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atery"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -75552,12 +75552,12 @@ pub static WORD_PLAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PLAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAL_CHILDREN),
+static WORD_PLAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("form"),
         dictgen::InsensitiveStr::Ascii("forms"),
@@ -75566,12 +75566,12 @@ pub static WORD_PLAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PLAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAI_CHILDREN),
+static WORD_PLAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("garism"),
         dictgen::InsensitiveStr::Ascii("ntest"),
@@ -75580,12 +75580,12 @@ pub static WORD_PLAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PLAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAG_CHILDREN),
+static WORD_PLAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("airism"),
         dictgen::InsensitiveStr::Ascii("arisim"),
@@ -75615,12 +75615,12 @@ pub static WORD_PLAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PLAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAF_CHILDREN),
+static WORD_PLAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orm"),
         dictgen::InsensitiveStr::Ascii("orms"),
@@ -75631,12 +75631,12 @@ pub static WORD_PLAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_PLAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAE_CHILDREN),
+static WORD_PLAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("stine"),
@@ -75652,23 +75652,23 @@ pub static WORD_PLAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PLAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAD_CHILDREN),
+static WORD_PLAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAD_CHILDREN),
     value: Some(&["plaid", "plead"]),
 };
 
-pub static WORD_PLAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["plaided", "pleaded"]],
     range: 2..=2,
 };
 
-static WORD_PLAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAC_CHILDREN),
+static WORD_PLAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ebro"),
@@ -75724,34 +75724,34 @@ pub static WORD_PLAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PLAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PLAB_CHILDREN),
+static WORD_PLAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PLAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PLAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PLAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eswalker")],
     values: &[&["planeswalker"]],
     range: 8..=8,
 };
 
-static WORD_PK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PK_CHILDREN),
+static WORD_PK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PK_CHILDREN),
     value: None,
 };
 
-pub static WORD_PK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aythroughs")],
     values: &[&["playthroughs"]],
     range: 10..=10,
 };
 
-static WORD_PI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PI_CHILDREN),
+static WORD_PI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PI_CHILDREN),
     value: None,
 };
 
-static WORD_PI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PIA_NODE),
     Some(&WORD_PIB_NODE),
     Some(&WORD_PIC_NODE),
@@ -75780,12 +75780,12 @@ static WORD_PI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIX_CHILDREN),
+static WORD_PIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elx"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -75794,12 +75794,12 @@ pub static WORD_PIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_PIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIV_CHILDREN),
+static WORD_PIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ott"),
         dictgen::InsensitiveStr::Ascii("otting"),
@@ -75808,12 +75808,12 @@ pub static WORD_PIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_PIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIT_CHILDREN),
+static WORD_PIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chferks"),
         dictgen::InsensitiveStr::Ascii("chfolks"),
@@ -75849,12 +75849,12 @@ pub static WORD_PIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIR_CHILDREN),
+static WORD_PIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eced"),
         dictgen::InsensitiveStr::Ascii("ric"),
@@ -75863,12 +75863,12 @@ pub static WORD_PIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_PIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIP_CHILDREN),
+static WORD_PIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eine"),
         dictgen::InsensitiveStr::Ascii("eines"),
@@ -75910,12 +75910,12 @@ pub static WORD_PIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_PIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIO_CHILDREN),
+static WORD_PIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lting"),
         dictgen::InsensitiveStr::Ascii("neeer"),
@@ -75939,12 +75939,12 @@ pub static WORD_PIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_PIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIN_CHILDREN),
+static WORD_PIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancle"),
         dictgen::InsensitiveStr::Ascii("apple"),
@@ -75984,12 +75984,12 @@ pub static WORD_PIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIM_CHILDREN),
+static WORD_PIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("xap"),
         dictgen::InsensitiveStr::Ascii("xaps"),
@@ -75998,12 +75998,12 @@ pub static WORD_PIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_PIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIL_CHILDREN),
+static WORD_PIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("girm"),
@@ -76037,12 +76037,12 @@ pub static WORD_PIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PIJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIJ_CHILDREN),
+static WORD_PIJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eon"),
         dictgen::InsensitiveStr::Ascii("eons"),
@@ -76053,12 +76053,12 @@ pub static WORD_PIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_PIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIG_CHILDREN),
+static WORD_PIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -76086,12 +76086,12 @@ pub static WORD_PIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_PIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIE_CHILDREN),
+static WORD_PIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceweise"),
         dictgen::InsensitiveStr::Ascii("cewice"),
@@ -76109,12 +76109,12 @@ pub static WORD_PIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_PIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIC_CHILDREN),
+static WORD_PIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -76194,23 +76194,23 @@ pub static WORD_PIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_PIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIB_CHILDREN),
+static WORD_PIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lisher")],
     values: &[&["publisher"]],
     range: 6..=6,
 };
 
-static WORD_PIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PIA_CHILDREN),
+static WORD_PIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nkillers"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -76224,12 +76224,12 @@ pub static WORD_PIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_PH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PH_CHILDREN),
+static WORD_PH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PH_CHILDREN),
     value: None,
 };
 
-static WORD_PH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PHA_NODE),
     None,
     None,
@@ -76258,12 +76258,12 @@ static WORD_PH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PHY_CHILDREN),
+static WORD_PHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PHY_CHILDREN),
     value: None,
 };
 
-static WORD_PHY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PHY_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_PHYC_NODE),
@@ -76292,12 +76292,12 @@ static WORD_PHY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PHYT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYT_CHILDREN),
+static WORD_PHYT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hon"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -76306,12 +76306,12 @@ pub static WORD_PHYT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PHYS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYS_CHILDREN),
+static WORD_PHYS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("cedelic"),
@@ -76407,12 +76407,12 @@ pub static WORD_PHYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_PHYL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYL_CHILDREN),
+static WORD_PHYL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("osophical"),
         dictgen::InsensitiveStr::Ascii("osophically"),
@@ -76421,12 +76421,12 @@ pub static WORD_PHYL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=11,
 };
 
-static WORD_PHYI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYI_CHILDREN),
+static WORD_PHYI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("scal"),
         dictgen::InsensitiveStr::Ascii("scally"),
@@ -76444,12 +76444,12 @@ pub static WORD_PHYI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PHYC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHYC_CHILDREN),
+static WORD_PHYC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHYC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHYC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHYC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hedelics"),
         dictgen::InsensitiveStr::Ascii("hiatrist"),
@@ -76481,12 +76481,12 @@ pub static WORD_PHYC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_PHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHT_CHILDREN),
+static WORD_PHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("read"),
         dictgen::InsensitiveStr::Ascii("reads"),
@@ -76495,12 +76495,12 @@ pub static WORD_PHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_PHS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHS_CHILDREN),
+static WORD_PHS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ycologically"),
@@ -76532,12 +76532,12 @@ pub static WORD_PHS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_PHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHR_CHILDREN),
+static WORD_PHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amaceutical"),
         dictgen::InsensitiveStr::Ascii("amacist"),
@@ -76547,12 +76547,12 @@ pub static WORD_PHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_PHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHO_CHILDREN),
+static WORD_PHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("entic"),
@@ -76666,12 +76666,12 @@ pub static WORD_PHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PHL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHL_CHILDREN),
+static WORD_PHL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("em"),
         dictgen::InsensitiveStr::Ascii("ema"),
@@ -76691,12 +76691,12 @@ pub static WORD_PHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PHI_CHILDREN),
+static WORD_PHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PHI_CHILDREN),
     value: None,
 };
 
-static WORD_PHI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PHI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PHIA_NODE),
     None,
     None,
@@ -76725,12 +76725,12 @@ static WORD_PHI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PHIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHIS_CHILDREN),
+static WORD_PHIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -76750,12 +76750,12 @@ pub static WORD_PHIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PHIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHIL_CHILDREN),
+static WORD_PHIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adalphia"),
         dictgen::InsensitiveStr::Ascii("adelhpia"),
@@ -76885,23 +76885,23 @@ pub static WORD_PHIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=12,
 };
 
-static WORD_PHIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHIA_CHILDREN),
+static WORD_PHIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ldelphia")],
     values: &[&["philadelphia"]],
     range: 8..=8,
 };
 
-static WORD_PHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHE_CHILDREN),
+static WORD_PHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("monena"),
         dictgen::InsensitiveStr::Ascii("monenon"),
@@ -76961,12 +76961,12 @@ pub static WORD_PHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_PHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PHA_CHILDREN),
+static WORD_PHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PHA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PHA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nthom"),
         dictgen::InsensitiveStr::Ascii("ntoom"),
@@ -77058,12 +77058,12 @@ pub static WORD_PHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_PE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PE_CHILDREN),
+static WORD_PE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PE_CHILDREN),
     value: None,
 };
 
-static WORD_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PEA_NODE),
     Some(&WORD_PEB_NODE),
     Some(&WORD_PEC_NODE),
@@ -77092,34 +77092,34 @@ static WORD_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_PEZ_NODE),
 ];
 
-static WORD_PEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEZ_CHILDREN),
+static WORD_PEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ier")],
     values: &[&["bezier"]],
     range: 3..=3,
 };
 
-static WORD_PEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEW_CHILDREN),
+static WORD_PEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("der")],
     values: &[&["lewder", "pewter", "powder"]],
     range: 3..=3,
 };
 
-static WORD_PEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEV_CHILDREN),
+static WORD_PEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -77128,23 +77128,23 @@ pub static WORD_PEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_PEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEU_CHILDREN),
+static WORD_PEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sdo")],
     values: &[&["pseudo"]],
     range: 3..=3,
 };
 
-static WORD_PET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PET_CHILDREN),
+static WORD_PET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PET_CHILDREN),
     value: None,
 };
 
-pub static WORD_PET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etion"),
         dictgen::InsensitiveStr::Ascii("rolem"),
@@ -77155,12 +77155,12 @@ pub static WORD_PET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_PES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PES_CHILDREN),
+static WORD_PES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PES_CHILDREN),
     value: None,
 };
 
-pub static WORD_PES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itcides"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -77202,12 +77202,12 @@ pub static WORD_PES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PER_CHILDREN),
+static WORD_PER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PER_CHILDREN),
     value: None,
 };
 
-static WORD_PER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PERA_NODE),
     None,
     Some(&WORD_PERC_NODE),
@@ -77236,23 +77236,23 @@ static WORD_PER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERX_CHILDREN),
+static WORD_PERX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERX_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oide")],
     values: &[&["peroxide"]],
     range: 4..=4,
 };
 
-static WORD_PERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERV_CHILDREN),
+static WORD_PERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ail"),
         dictgen::InsensitiveStr::Ascii("ailing"),
@@ -77280,23 +77280,23 @@ pub static WORD_PERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERU_CHILDREN),
+static WORD_PERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("saded")],
     values: &[&["persuaded"]],
     range: 5..=5,
 };
 
-static WORD_PERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERT_CHILDREN),
+static WORD_PERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("ended"),
@@ -77368,12 +77368,12 @@ pub static WORD_PERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PERS_CHILDREN),
+static WORD_PERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PERS_CHILDREN),
     value: None,
 };
 
-static WORD_PERS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PERS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PERSA_NODE),
     None,
     Some(&WORD_PERSC_NODE),
@@ -77402,34 +77402,34 @@ static WORD_PERS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERSW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSW_CHILDREN),
+static WORD_PERSW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("asion")],
     values: &[&["persuasion"]],
     range: 5..=5,
 };
 
-static WORD_PERSV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSV_CHILDREN),
+static WORD_PERSV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("asive")],
     values: &[&["persuasive"]],
     range: 5..=5,
 };
 
-static WORD_PERSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSU_CHILDREN),
+static WORD_PERSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("asian"),
@@ -77481,23 +77481,23 @@ pub static WORD_PERSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PERST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERST_CHILDREN),
+static WORD_PERST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERST_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ige")],
     values: &[&["prestige"]],
     range: 3..=3,
 };
 
-static WORD_PERSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSS_CHILDREN),
+static WORD_PERSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ious"),
         dictgen::InsensitiveStr::Ascii("iously"),
@@ -77513,12 +77513,12 @@ pub static WORD_PERSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PERSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSP_CHILDREN),
+static WORD_PERSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecitve"),
         dictgen::InsensitiveStr::Ascii("ecitves"),
@@ -77540,12 +77540,12 @@ pub static WORD_PERSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PERSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSO_CHILDREN),
+static WORD_PERSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anl"),
         dictgen::InsensitiveStr::Ascii("anlly"),
@@ -77611,23 +77611,23 @@ pub static WORD_PERSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PERSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSM_CHILDREN),
+static WORD_PERSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("issions")],
     values: &[&["permissions"]],
     range: 7..=7,
 };
 
-static WORD_PERSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSI_CHILDREN),
+static WORD_PERSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cuted"),
         dictgen::InsensitiveStr::Ascii("cution"),
@@ -77675,12 +77675,12 @@ pub static WORD_PERSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PERSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSH_CHILDREN),
+static WORD_PERSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("is"),
         dictgen::InsensitiveStr::Ascii("isly"),
@@ -77696,12 +77696,12 @@ pub static WORD_PERSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PERSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSE_CHILDREN),
+static WORD_PERSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctive"),
         dictgen::InsensitiveStr::Ascii("ctives"),
@@ -77783,12 +77783,12 @@ pub static WORD_PERSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PERSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSC_CHILDREN),
+static WORD_PERSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eptive"),
         dictgen::InsensitiveStr::Ascii("iuos"),
@@ -77812,12 +77812,12 @@ pub static WORD_PERSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PERSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERSA_CHILDREN),
+static WORD_PERSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -77837,12 +77837,12 @@ pub static WORD_PERSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_PERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERR_CHILDREN),
+static WORD_PERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ogative"),
         dictgen::InsensitiveStr::Ascii("ror"),
@@ -77851,12 +77851,12 @@ pub static WORD_PERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERP_CHILDREN),
+static WORD_PERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aid"),
         dictgen::InsensitiveStr::Ascii("andicular"),
@@ -77982,12 +77982,12 @@ pub static WORD_PERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_PERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERO_CHILDREN),
+static WORD_PERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dically"),
         dictgen::InsensitiveStr::Ascii("endicular"),
@@ -78033,12 +78033,12 @@ pub static WORD_PERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERN_CHILDREN),
+static WORD_PERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ament"),
         dictgen::InsensitiveStr::Ascii("amently"),
@@ -78047,12 +78047,12 @@ pub static WORD_PERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_PERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PERM_CHILDREN),
+static WORD_PERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PERM_CHILDREN),
     value: None,
 };
 
-static WORD_PERM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PERM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PERMA_NODE),
     None,
     None,
@@ -78081,12 +78081,12 @@ static WORD_PERM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMU_CHILDREN),
+static WORD_PERMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atate"),
         dictgen::InsensitiveStr::Ascii("atated"),
@@ -78126,23 +78126,23 @@ pub static WORD_PERMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PERMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMT_CHILDREN),
+static WORD_PERMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uation")],
     values: &[&["permutation"]],
     range: 6..=6,
 };
 
-static WORD_PERMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMS_CHILDREN),
+static WORD_PERMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sion"),
         dictgen::InsensitiveStr::Ascii("sions"),
@@ -78151,23 +78151,23 @@ pub static WORD_PERMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PERMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMO_CHILDREN),
+static WORD_PERMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rmance")],
     values: &[&["performance"]],
     range: 6..=6,
 };
 
-static WORD_PERMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMM_CHILDREN),
+static WORD_PERMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ission"),
         dictgen::InsensitiveStr::Ascii("issions"),
@@ -78176,12 +78176,12 @@ pub static WORD_PERMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_PERMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMI_CHILDREN),
+static WORD_PERMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ere"),
@@ -78255,12 +78255,12 @@ pub static WORD_PERMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PERME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERME_CHILDREN),
+static WORD_PERME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERME_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nant"),
         dictgen::InsensitiveStr::Ascii("nantly"),
@@ -78280,12 +78280,12 @@ pub static WORD_PERME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PERMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERMA_CHILDREN),
+static WORD_PERMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -78321,12 +78321,12 @@ pub static WORD_PERMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERL_CHILDREN),
+static WORD_PERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciritc"),
         dictgen::InsensitiveStr::Ascii("iferate"),
@@ -78346,12 +78346,12 @@ pub static WORD_PERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_PERJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERJ_CHILDREN),
+static WORD_PERJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ery"),
         dictgen::InsensitiveStr::Ascii("orative"),
@@ -78360,12 +78360,12 @@ pub static WORD_PERJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERI_CHILDREN),
+static WORD_PERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("cings"),
@@ -78473,12 +78473,12 @@ pub static WORD_PERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PERH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERH_CHILDREN),
+static WORD_PERH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abs"),
         dictgen::InsensitiveStr::Ascii("arps"),
@@ -78502,12 +78502,12 @@ pub static WORD_PERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PERF_CHILDREN),
+static WORD_PERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PERF_CHILDREN),
     value: None,
 };
 
-static WORD_PERF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PERF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -78536,12 +78536,12 @@ static WORD_PERF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFU_CHILDREN),
+static WORD_PERFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rd"),
@@ -78565,12 +78565,12 @@ pub static WORD_PERFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_PERFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFR_CHILDREN),
+static WORD_PERFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("om"),
@@ -78596,12 +78596,12 @@ pub static WORD_PERFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PERFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PERFO_CHILDREN),
+static WORD_PERFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PERFO_CHILDREN),
     value: None,
 };
 
-static WORD_PERFO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PERFO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -78630,12 +78630,12 @@ static WORD_PERFO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PERFOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFOR_CHILDREN),
+static WORD_PERFOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFOR_CHILDREN),
     value: Some(&["perform"]),
 };
 
-pub static WORD_PERFOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("amed"),
@@ -78715,23 +78715,23 @@ pub static WORD_PERFOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_PERFOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFOO_CHILDREN),
+static WORD_PERFOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("m")],
     values: &[&["perfume", "perform"]],
     range: 1..=1,
 };
 
-static WORD_PERFOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFOM_CHILDREN),
+static WORD_PERFOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFOM_CHILDREN),
     value: Some(&["perform"]),
 };
 
-pub static WORD_PERFOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amce"),
         dictgen::InsensitiveStr::Ascii("amces"),
@@ -78827,12 +78827,12 @@ pub static WORD_PERFOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PERFOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFOE_CHILDREN),
+static WORD_PERFOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mamce"),
@@ -78870,34 +78870,34 @@ pub static WORD_PERFOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_PERFM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFM_CHILDREN),
+static WORD_PERFM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ormance")],
     values: &[&["performance"]],
     range: 7..=7,
 };
 
-static WORD_PERFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFI_CHILDREN),
+static WORD_PERFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("x")],
     values: &[&["prefix"]],
     range: 1..=1,
 };
 
-static WORD_PERFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERFE_CHILDREN),
+static WORD_PERFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ccion"),
@@ -78995,12 +78995,12 @@ pub static WORD_PERFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERE_CHILDREN),
+static WORD_PERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("miter"),
         dictgen::InsensitiveStr::Ascii("nially"),
@@ -79020,12 +79020,12 @@ pub static WORD_PERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERD_CHILDREN),
+static WORD_PERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ators"),
         dictgen::InsensitiveStr::Ascii("icament"),
@@ -79051,12 +79051,12 @@ pub static WORD_PERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERC_CHILDREN),
+static WORD_PERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antage"),
         dictgen::InsensitiveStr::Ascii("antages"),
@@ -79158,12 +79158,12 @@ pub static WORD_PERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PERA_CHILDREN),
+static WORD_PERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("phs"),
@@ -79172,12 +79172,12 @@ pub static WORD_PERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEP_CHILDREN),
+static WORD_PEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("le"),
@@ -79209,12 +79209,12 @@ pub static WORD_PEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_PEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEO_CHILDREN),
+static WORD_PEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dphile"),
         dictgen::InsensitiveStr::Ascii("dphiles"),
@@ -79246,12 +79246,12 @@ pub static WORD_PEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_PEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PEN_CHILDREN),
+static WORD_PEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PEN_CHILDREN),
     value: None,
 };
 
-static WORD_PEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PENA_NODE),
     None,
     Some(&WORD_PENC_NODE),
@@ -79280,34 +79280,34 @@ static WORD_PEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PENW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENW_CHILDREN),
+static WORD_PENW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ar")],
     values: &[&["peignoir"]],
     range: 2..=2,
 };
 
-static WORD_PENU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENU_CHILDREN),
+static WORD_PENU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ltimante")],
     values: &[&["penultimate"]],
     range: 8..=8,
 };
 
-static WORD_PENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENT_CHILDREN),
+static WORD_PENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agoon"),
         dictgen::InsensitiveStr::Ascii("alty"),
@@ -79318,12 +79318,12 @@ pub static WORD_PENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PENS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENS_CHILDREN),
+static WORD_PENS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("ino"),
@@ -79343,12 +79343,12 @@ pub static WORD_PENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENN_CHILDREN),
+static WORD_PENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("als"),
@@ -79396,12 +79396,12 @@ pub static WORD_PENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_PENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENI_CHILDREN),
+static WORD_PENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cls"),
         dictgen::InsensitiveStr::Ascii("ndg"),
@@ -79433,12 +79433,12 @@ pub static WORD_PENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PENG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENG_CHILDREN),
+static WORD_PENG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iuns"),
         dictgen::InsensitiveStr::Ascii("uines"),
@@ -79468,12 +79468,12 @@ pub static WORD_PENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENE_CHILDREN),
+static WORD_PENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rator"),
         dictgen::InsensitiveStr::Ascii("tracion"),
@@ -79497,12 +79497,12 @@ pub static WORD_PENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_PEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEND_CHILDREN),
+static WORD_PEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antic"),
         dictgen::InsensitiveStr::Ascii("atic"),
@@ -79524,23 +79524,23 @@ pub static WORD_PEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENC_CHILDREN),
+static WORD_PENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iles")],
     values: &[&["pencils"]],
     range: 4..=4,
 };
 
-static WORD_PENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PENA_CHILDREN),
+static WORD_PENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lites"),
         dictgen::InsensitiveStr::Ascii("lities"),
@@ -79566,23 +79566,23 @@ pub static WORD_PENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEM_CHILDREN),
+static WORD_PEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("issions")],
     values: &[&["permissions"]],
     range: 7..=7,
 };
 
-static WORD_PEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEL_CHILDREN),
+static WORD_PEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("oponnes"),
@@ -79591,12 +79591,12 @@ pub static WORD_PEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEI_CHILDREN),
+static WORD_PEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cemeal"),
@@ -79628,34 +79628,34 @@ pub static WORD_PEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_PEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEH_CHILDREN),
+static WORD_PEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aps")],
     values: &[&["perhaps"]],
     range: 3..=3,
 };
 
-static WORD_PEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEG_CHILDREN),
+static WORD_PEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["page"]],
     range: 1..=1,
 };
 
-static WORD_PEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEF_CHILDREN),
+static WORD_PEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ectly"),
@@ -79701,12 +79701,12 @@ pub static WORD_PEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEE_CHILDREN),
+static WORD_PEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dmont"),
         dictgen::InsensitiveStr::Ascii("dmonts"),
@@ -79728,12 +79728,12 @@ pub static WORD_PEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PED_CHILDREN),
+static WORD_PED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PED_CHILDREN),
     value: None,
 };
 
-pub static WORD_PED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antisch"),
         dictgen::InsensitiveStr::Ascii("astal"),
@@ -79791,12 +79791,12 @@ pub static WORD_PED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_PEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEC_CHILDREN),
+static WORD_PEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entage"),
         dictgen::InsensitiveStr::Ascii("ified"),
@@ -79822,12 +79822,12 @@ pub static WORD_PEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_PEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEB_CHILDREN),
+static WORD_PEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bels"),
         dictgen::InsensitiveStr::Ascii("bleos"),
@@ -79838,12 +79838,12 @@ pub static WORD_PEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_PEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PEA_CHILDREN),
+static WORD_PEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cd"),
         dictgen::InsensitiveStr::Ascii("cefullly"),
@@ -79895,12 +79895,12 @@ pub static WORD_PEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PB_CHILDREN),
+static WORD_PB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lisher"),
         dictgen::InsensitiveStr::Ascii("ulisher"),
@@ -79909,12 +79909,12 @@ pub static WORD_PB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_PA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PA_CHILDREN),
+static WORD_PA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PA_CHILDREN),
     value: None,
 };
 
-static WORD_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PAA_NODE),
     Some(&WORD_PAB_NODE),
     Some(&WORD_PAC_NODE),
@@ -79943,12 +79943,12 @@ static WORD_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAY_CHILDREN),
+static WORD_PAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chedelics"),
         dictgen::InsensitiveStr::Ascii("chiatrist"),
@@ -79984,12 +79984,12 @@ pub static WORD_PAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_PAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAV_CHILDREN),
+static WORD_PAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("illion"),
         dictgen::InsensitiveStr::Ascii("illions"),
@@ -79998,12 +79998,12 @@ pub static WORD_PAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_PAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PAT_CHILDREN),
+static WORD_PAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PAT_CHILDREN),
     value: None,
 };
 
-static WORD_PAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PATA_NODE),
     None,
     Some(&WORD_PATC_NODE),
@@ -80032,12 +80032,12 @@ static WORD_PAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATT_CHILDREN),
+static WORD_PATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ened"),
@@ -80065,12 +80065,12 @@ pub static WORD_PATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATR_CHILDREN),
+static WORD_PATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("airchy"),
         dictgen::InsensitiveStr::Ascii("cik"),
@@ -80150,12 +80150,12 @@ pub static WORD_PATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATI_CHILDREN),
+static WORD_PATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -80191,12 +80191,12 @@ pub static WORD_PATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PATH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATH_CHILDREN),
+static WORD_PATH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alogical"),
         dictgen::InsensitiveStr::Ascii("ame"),
@@ -80242,12 +80242,12 @@ pub static WORD_PATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_PATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATE_CHILDREN),
+static WORD_PATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ince"),
         dictgen::InsensitiveStr::Ascii("int"),
@@ -80271,12 +80271,12 @@ pub static WORD_PATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATC_CHILDREN),
+static WORD_PATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hs"),
         dictgen::InsensitiveStr::Ascii("ket"),
@@ -80286,12 +80286,12 @@ pub static WORD_PATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_PATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PATA_CHILDREN),
+static WORD_PATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meter"),
         dictgen::InsensitiveStr::Ascii("meters"),
@@ -80300,12 +80300,12 @@ pub static WORD_PATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PAS_CHILDREN),
+static WORD_PAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PAS_CHILDREN),
     value: None,
 };
 
-static WORD_PAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PAS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PASA_NODE),
     None,
     Some(&WORD_PASC_NODE),
@@ -80334,12 +80334,12 @@ static WORD_PAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PASW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASW_CHILDREN),
+static WORD_PASW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASW_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ord"),
         dictgen::InsensitiveStr::Ascii("ords"),
@@ -80348,23 +80348,23 @@ pub static WORD_PASW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_PASU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASU_CHILDREN),
+static WORD_PASU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["pausing"]],
     range: 3..=3,
 };
 
-static WORD_PAST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAST_CHILDREN),
+static WORD_PAST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAST_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eing"),
         dictgen::InsensitiveStr::Ascii("eries"),
@@ -80402,12 +80402,12 @@ pub static WORD_PAST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_PASS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASS_CHILDREN),
+static WORD_PASS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("abel"),
@@ -80511,12 +80511,12 @@ pub static WORD_PASS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PASR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASR_CHILDREN),
+static WORD_PASR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -80527,12 +80527,12 @@ pub static WORD_PASR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_PASI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASI_CHILDREN),
+static WORD_PASI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("tioning"),
@@ -80542,23 +80542,23 @@ pub static WORD_PASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_PASH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASH_CHILDREN),
+static WORD_PASH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASH_CHILDREN),
     value: Some(&["hash"]),
 };
 
-pub static WORD_PASH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PASE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASE_CHILDREN),
+static WORD_PASE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASE_CHILDREN),
     value: Some(&["pass", "pace", "parse", "phase"]),
 };
 
-pub static WORD_PASE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ngers"),
@@ -80574,12 +80574,12 @@ pub static WORD_PASE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_PASC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASC_CHILDREN),
+static WORD_PASC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heurisation"),
         dictgen::InsensitiveStr::Ascii("heurise"),
@@ -80627,23 +80627,23 @@ pub static WORD_PASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=11,
 };
 
-static WORD_PASA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PASA_CHILDREN),
+static WORD_PASA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PASA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PASA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sword")],
     values: &[&["password"]],
     range: 5..=5,
 };
 
-static WORD_PAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PAR_CHILDREN),
+static WORD_PAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PAR_CHILDREN),
     value: None,
 };
 
-static WORD_PAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARA_NODE),
     None,
     Some(&WORD_PARC_NODE),
@@ -80672,23 +80672,23 @@ static WORD_PAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARY_CHILDREN),
+static WORD_PARY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARY_CHILDREN),
     value: Some(&["party", "parry"]),
 };
 
-pub static WORD_PARY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PART_CHILDREN),
+static WORD_PART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PART_CHILDREN),
     value: None,
 };
 
-static WORD_PART_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PART_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARTA_NODE),
     None,
     Some(&WORD_PARTC_NODE),
@@ -80717,23 +80717,23 @@ static WORD_PART_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTS_CHILDREN),
+static WORD_PARTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ian")],
     values: &[&["partisan"]],
     range: 3..=3,
 };
 
-static WORD_PARTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTO_CHILDREN),
+static WORD_PARTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ls"),
         dictgen::InsensitiveStr::Ascii("nizing"),
@@ -80742,12 +80742,12 @@ pub static WORD_PARTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PARTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTN_CHILDREN),
+static WORD_PARTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erd"),
         dictgen::InsensitiveStr::Ascii("etship"),
@@ -80756,12 +80756,12 @@ pub static WORD_PARTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_PARTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PARTI_CHILDREN),
+static WORD_PARTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PARTI_CHILDREN),
     value: None,
 };
 
-static WORD_PARTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PARTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARTIA_NODE),
     None,
     Some(&WORD_PARTIC_NODE),
@@ -80790,23 +80790,23 @@ static WORD_PARTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARTIZ_NODE),
 ];
 
-static WORD_PARTIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIZ_CHILDREN),
+static WORD_PARTIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ipation")],
     values: &[&["participation"]],
     range: 7..=7,
 };
 
-static WORD_PARTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIU_CHILDREN),
+static WORD_PARTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("la"),
         dictgen::InsensitiveStr::Ascii("lar"),
@@ -80822,12 +80822,12 @@ pub static WORD_PARTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_PARTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIT_CHILDREN),
+static WORD_PARTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("icipant"),
@@ -80865,12 +80865,12 @@ pub static WORD_PARTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_PARTIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIS_CHILDREN),
+static WORD_PARTIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -80890,12 +80890,12 @@ pub static WORD_PARTIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PARTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIR_CHILDREN),
+static WORD_PARTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ioned"),
@@ -80911,12 +80911,12 @@ pub static WORD_PARTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PARTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIO_CHILDREN),
+static WORD_PARTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -80940,12 +80940,12 @@ pub static WORD_PARTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_PARTII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTII_CHILDREN),
+static WORD_PARTII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTII_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ton"),
         dictgen::InsensitiveStr::Ascii("toned"),
@@ -80961,23 +80961,23 @@ pub static WORD_PARTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PARTIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIF_CHILDREN),
+static WORD_PARTIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ular")],
     values: &[&["particular"]],
     range: 4..=4,
 };
 
-static WORD_PARTIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIE_CHILDREN),
+static WORD_PARTIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -80986,12 +80986,12 @@ pub static WORD_PARTIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_PARTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PARTIC_CHILDREN),
+static WORD_PARTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PARTIC_CHILDREN),
     value: None,
 };
 
-static WORD_PARTIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PARTIC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARTICA_NODE),
     None,
     None,
@@ -81020,12 +81020,12 @@ static WORD_PARTIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARTICU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICU_CHILDREN),
+static WORD_PARTICU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICU_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -81063,12 +81063,12 @@ pub static WORD_PARTICU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_PARTICP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICP_CHILDREN),
+static WORD_PARTICP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -81090,12 +81090,12 @@ pub static WORD_PARTICP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=5,
 };
 
-static WORD_PARTICL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICL_CHILDREN),
+static WORD_PARTICL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -81105,23 +81105,23 @@ pub static WORD_PARTICL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=3,
 };
 
-static WORD_PARTICK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICK_CHILDREN),
+static WORD_PARTICK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICK_CHILDREN),
     value: Some(&["patrick"]),
 };
 
-pub static WORD_PARTICK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PARTICI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICI_CHILDREN),
+static WORD_PARTICI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apnts"),
         dictgen::InsensitiveStr::Ascii("apte"),
@@ -81181,23 +81181,23 @@ pub static WORD_PARTICI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=7,
 };
 
-static WORD_PARTICE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICE_CHILDREN),
+static WORD_PARTICE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICE_CHILDREN),
     value: Some(&["particle"]),
 };
 
-pub static WORD_PARTICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["particle"]],
     range: 1..=1,
 };
 
-static WORD_PARTICA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTICA_CHILDREN),
+static WORD_PARTICA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTICA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTICA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lar"),
@@ -81241,12 +81241,12 @@ pub static WORD_PARTICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_PARTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTIA_CHILDREN),
+static WORD_PARTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lially"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -81264,23 +81264,23 @@ pub static WORD_PARTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_PARTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTH_CHILDREN),
+static WORD_PARTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTH_CHILDREN),
     value: Some(&["path"]),
 };
 
-pub static WORD_PARTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PARTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTE_CHILDREN),
+static WORD_PARTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cipant"),
         dictgen::InsensitiveStr::Ascii("cipants"),
@@ -81304,12 +81304,12 @@ pub static WORD_PARTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PARTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTC_CHILDREN),
+static WORD_PARTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hett"),
         dictgen::InsensitiveStr::Ascii("ipate"),
@@ -81327,23 +81327,23 @@ pub static WORD_PARTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PARTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARTA_CHILDREN),
+static WORD_PARTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ining")],
     values: &[&["pertaining"]],
     range: 5..=5,
 };
 
-static WORD_PARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARS_CHILDREN),
+static WORD_PARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ef"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -81371,12 +81371,12 @@ pub static WORD_PARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARR_CHILDREN),
+static WORD_PARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alel"),
         dictgen::InsensitiveStr::Ascii("alell"),
@@ -81402,12 +81402,12 @@ pub static WORD_PARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_PARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARO_CHILDREN),
+static WORD_PARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cheal"),
         dictgen::InsensitiveStr::Ascii("cheality"),
@@ -81439,12 +81439,12 @@ pub static WORD_PARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_PARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARN_CHILDREN),
+static WORD_PARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oia"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -81466,12 +81466,12 @@ pub static WORD_PARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_PARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARM_CHILDREN),
+static WORD_PARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARM_CHILDREN),
     value: Some(&["param", "pram", "parma"]),
 };
 
-pub static WORD_PARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeter"),
         dictgen::InsensitiveStr::Ascii("aeters"),
@@ -81515,12 +81515,12 @@ pub static WORD_PARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_PARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARL_CHILDREN),
+static WORD_PARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aiment"),
         dictgen::InsensitiveStr::Ascii("aimentary"),
@@ -81564,12 +81564,12 @@ pub static WORD_PARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_PARK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARK_CHILDREN),
+static WORD_PARK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARK_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -81581,12 +81581,12 @@ pub static WORD_PARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_PARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARI_CHILDREN),
+static WORD_PARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("al"),
@@ -81648,34 +81648,34 @@ pub static WORD_PARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARG_CHILDREN),
+static WORD_PARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["large"]],
     range: 1..=1,
 };
 
-static WORD_PARF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARF_CHILDREN),
+static WORD_PARF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ay")],
     values: &[&["parfait"]],
     range: 2..=2,
 };
 
-static WORD_PARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARE_CHILDREN),
+static WORD_PARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llel"),
         dictgen::InsensitiveStr::Ascii("llelogram"),
@@ -81733,23 +81733,23 @@ pub static WORD_PARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_PARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARD_CHILDREN),
+static WORD_PARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARD_CHILDREN),
     value: Some(&["part"]),
 };
 
-pub static WORD_PARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_PARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARC_CHILDREN),
+static WORD_PARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tical"),
         dictgen::InsensitiveStr::Ascii("tically"),
@@ -81759,12 +81759,12 @@ pub static WORD_PARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_PARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PARA_CHILDREN),
+static WORD_PARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PARA_CHILDREN),
     value: None,
 };
 
-static WORD_PARA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PARA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_PARAC_NODE),
@@ -81793,12 +81793,12 @@ static WORD_PARA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAY_CHILDREN),
+static WORD_PARAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lsis"),
         dictgen::InsensitiveStr::Ascii("lzed"),
@@ -81807,12 +81807,12 @@ pub static WORD_PARAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_PARAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAV_CHILDREN),
+static WORD_PARAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irtualiation"),
         dictgen::InsensitiveStr::Ascii("irtualied"),
@@ -81836,12 +81836,12 @@ pub static WORD_PARAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=13,
 };
 
-static WORD_PARAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAT_CHILDREN),
+static WORD_PARAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heses"),
         dictgen::InsensitiveStr::Ascii("mers"),
@@ -81850,12 +81850,12 @@ pub static WORD_PARAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_PARAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAS_CHILDREN),
+static WORD_PARAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ide"),
@@ -81881,12 +81881,12 @@ pub static WORD_PARAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PARAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAR_CHILDREN),
+static WORD_PARAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agraph"),
         dictgen::InsensitiveStr::Ascii("aph"),
@@ -81912,12 +81912,12 @@ pub static WORD_PARAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_PARAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAP_CHILDREN),
+static WORD_PARAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hanalia"),
         dictgen::InsensitiveStr::Ascii("harse"),
@@ -81953,12 +81953,12 @@ pub static WORD_PARAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_PARAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAN_CHILDREN),
+static WORD_PARAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("eter"),
@@ -82004,12 +82004,12 @@ pub static WORD_PARAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_PARAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_PARAM_CHILDREN),
+static WORD_PARAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_PARAM_CHILDREN),
     value: None,
 };
 
-static WORD_PARAM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_PARAM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_PARAMA_NODE),
     None,
     None,
@@ -82038,12 +82038,12 @@ static WORD_PARAM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_PARAMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMT_CHILDREN),
+static WORD_PARAMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erer"),
@@ -82091,56 +82091,56 @@ pub static WORD_PARAMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_PARAMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMS_CHILDREN),
+static WORD_PARAMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["params"]],
     range: 1..=1,
 };
 
-static WORD_PARAMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMO_CHILDREN),
+static WORD_PARAMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rmal")],
     values: &[&["paranormal"]],
     range: 4..=4,
 };
 
-static WORD_PARAMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMN_CHILDREN),
+static WORD_PARAMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etrized")],
     values: &[&["parameterized"]],
     range: 7..=7,
 };
 
-static WORD_PARAMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMI_CHILDREN),
+static WORD_PARAMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ters")],
     values: &[&["parameters"]],
     range: 4..=4,
 };
 
-static WORD_PARAME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAME_CHILDREN),
+static WORD_PARAME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAME_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cias"),
         dictgen::InsensitiveStr::Ascii("dicks"),
@@ -82236,12 +82236,12 @@ pub static WORD_PARAME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_PARAMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAMA_CHILDREN),
+static WORD_PARAMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dics"),
         dictgen::InsensitiveStr::Ascii("meter"),
@@ -82259,12 +82259,12 @@ pub static WORD_PARAMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_PARAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAL_CHILDREN),
+static WORD_PARAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("elising"),
@@ -82336,23 +82336,23 @@ pub static WORD_PARAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_PARAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAI_CHILDREN),
+static WORD_PARAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ste")],
     values: &[&["parasite"]],
     range: 3..=3,
 };
 
-static WORD_PARAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAH_CHILDREN),
+static WORD_PARAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aps"),
         dictgen::InsensitiveStr::Ascii("prase"),
@@ -82361,12 +82361,12 @@ pub static WORD_PARAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_PARAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAG_CHILDREN),
+static WORD_PARAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aph"),
         dictgen::InsensitiveStr::Ascii("araph"),
@@ -82416,23 +82416,23 @@ pub static WORD_PARAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_PARAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAF_CHILDREN),
+static WORD_PARAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("analia")],
     values: &[&["paraphernalia"]],
     range: 6..=6,
 };
 
-static WORD_PARAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAE_CHILDREN),
+static WORD_PARAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meter"),
         dictgen::InsensitiveStr::Ascii("meters"),
@@ -82448,12 +82448,12 @@ pub static WORD_PARAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_PARAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAD_CHILDREN),
+static WORD_PARAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emics"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -82479,12 +82479,12 @@ pub static WORD_PARAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_PARAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PARAC_CHILDREN),
+static WORD_PARAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PARAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PARAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PARAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hutage"),
         dictgen::InsensitiveStr::Ascii("hutte"),
@@ -82493,12 +82493,12 @@ pub static WORD_PARAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_PAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAP_CHILDREN),
+static WORD_PAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("anicalou"),
@@ -82508,12 +82508,12 @@ pub static WORD_PAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_PAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAO_CHILDREN),
+static WORD_PAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -82522,12 +82522,12 @@ pub static WORD_PAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_PAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAN_CHILDREN),
+static WORD_PAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asoic"),
         dictgen::InsensitiveStr::Ascii("c"),
@@ -82581,12 +82581,12 @@ pub static WORD_PAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_PAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAM_CHILDREN),
+static WORD_PAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("flet"),
         dictgen::InsensitiveStr::Ascii("plet"),
@@ -82595,12 +82595,12 @@ pub static WORD_PAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_PAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAL_CHILDREN),
+static WORD_PAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adines"),
         dictgen::InsensitiveStr::Ascii("adinlst"),
@@ -82730,12 +82730,12 @@ pub static WORD_PAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_PAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAK_CHILDREN),
+static WORD_PAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ageimpl"),
@@ -82773,12 +82773,12 @@ pub static WORD_PAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_PAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAI_CHILDREN),
+static WORD_PAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -82844,12 +82844,12 @@ pub static WORD_PAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_PAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAH_CHILDREN),
+static WORD_PAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntom"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -82867,12 +82867,12 @@ pub static WORD_PAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_PAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAG_CHILDREN),
+static WORD_PAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agraph"),
         dictgen::InsensitiveStr::Ascii("ckage"),
@@ -82894,23 +82894,23 @@ pub static WORD_PAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_PAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAF_CHILDREN),
+static WORD_PAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icist")],
     values: &[&["pacifist"]],
     range: 5..=5,
 };
 
-static WORD_PAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAE_CHILDREN),
+static WORD_PAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rmission"),
         dictgen::InsensitiveStr::Ascii("rmissions"),
@@ -82921,12 +82921,12 @@ pub static WORD_PAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_PAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAD_CHILDREN),
+static WORD_PAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -82944,12 +82944,12 @@ pub static WORD_PAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_PAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAC_CHILDREN),
+static WORD_PAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -83073,23 +83073,23 @@ pub static WORD_PAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_PAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAB_CHILDREN),
+static WORD_PAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("el")],
     values: &[&["panel"]],
     range: 2..=2,
 };
 
-static WORD_PAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_PAA_CHILDREN),
+static WORD_PAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_PAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_PAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_PAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckage"),
         dictgen::InsensitiveStr::Ascii("ckages"),
@@ -83100,12 +83100,12 @@ pub static WORD_PAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_O_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_O_CHILDREN),
+static WORD_O_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_O_CHILDREN),
     value: None,
 };
 
-static WORD_O_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_O_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OA_NODE),
     Some(&WORD_OB_NODE),
     Some(&WORD_OC_NODE),
@@ -83134,12 +83134,12 @@ static WORD_O_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OY_CHILDREN),
+static WORD_OY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OY_CHILDREN),
     value: None,
 };
 
-pub static WORD_OY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lmpic"),
         dictgen::InsensitiveStr::Ascii("lmpics"),
@@ -83149,12 +83149,12 @@ pub static WORD_OY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_OX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OX_CHILDREN),
+static WORD_OX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OX_CHILDREN),
     value: None,
 };
 
-pub static WORD_OX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igen"),
         dictgen::InsensitiveStr::Ascii("imoron"),
@@ -83164,12 +83164,12 @@ pub static WORD_OX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_OW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OW_CHILDREN),
+static WORD_OW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OW_CHILDREN),
     value: None,
 };
 
-pub static WORD_OW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ened"),
         dictgen::InsensitiveStr::Ascii("ener"),
@@ -83237,12 +83237,12 @@ pub static WORD_OW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_OV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OV_CHILDREN),
+static WORD_OV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OV_CHILDREN),
     value: None,
 };
 
-static WORD_OV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -83271,12 +83271,12 @@ static WORD_OV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OVV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVV_CHILDREN),
+static WORD_OVV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVV_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eride"),
         dictgen::InsensitiveStr::Ascii("erridden"),
@@ -83294,12 +83294,12 @@ pub static WORD_OVV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_OVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVS_CHILDREN),
+static WORD_OVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ervable"),
         dictgen::InsensitiveStr::Ascii("ervation"),
@@ -83317,12 +83317,12 @@ pub static WORD_OVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_OVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVR_CHILDREN),
+static WORD_OVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ide"),
         dictgen::InsensitiveStr::Ascii("ides"),
@@ -83342,12 +83342,12 @@ pub static WORD_OVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_OVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OVE_CHILDREN),
+static WORD_OVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OVE_CHILDREN),
     value: Some(&["oven", "over"]),
 };
 
-static WORD_OVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OVE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -83376,12 +83376,12 @@ static WORD_OVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OVEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVEW_CHILDREN),
+static WORD_OVEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ritable"),
         dictgen::InsensitiveStr::Ascii("rite"),
@@ -83401,12 +83401,12 @@ pub static WORD_OVEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_OVER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OVER_CHILDREN),
+static WORD_OVER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OVER_CHILDREN),
     value: None,
 };
 
-static WORD_OVER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OVER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OVERA_NODE),
     Some(&WORD_OVERB_NODE),
     Some(&WORD_OVERC_NODE),
@@ -83435,12 +83435,12 @@ static WORD_OVER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_OVERZ_NODE),
 ];
 
-static WORD_OVERZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERZ_CHILDREN),
+static WORD_OVERZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ealis"),
         dictgen::InsensitiveStr::Ascii("ealisly"),
@@ -83476,23 +83476,23 @@ pub static WORD_OVERZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_OVERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERY_CHILDREN),
+static WORD_OVERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERY_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hped")],
     values: &[&["overhyped"]],
     range: 4..=4,
 };
 
-static WORD_OVERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERW_CHILDREN),
+static WORD_OVERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ath"),
         dictgen::InsensitiveStr::Ascii("ealmed"),
@@ -83592,12 +83592,12 @@ pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_OVERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERV_CHILDREN),
+static WORD_OVERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ise"),
         dictgen::InsensitiveStr::Ascii("ize"),
@@ -83619,12 +83619,12 @@ pub static WORD_OVERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_OVERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERU_CHILDREN),
+static WORD_OVERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("les"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -83633,12 +83633,12 @@ pub static WORD_OVERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_OVERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERT_CHILDREN),
+static WORD_OVERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apping"),
         dictgen::InsensitiveStr::Ascii("hining"),
@@ -83660,12 +83660,12 @@ pub static WORD_OVERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_OVERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERS_CHILDREN),
+static WORD_OVERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emplification"),
         dictgen::InsensitiveStr::Ascii("etimating"),
@@ -83721,12 +83721,12 @@ pub static WORD_OVERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=14,
 };
 
-static WORD_OVERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERR_CHILDREN),
+static WORD_OVERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ading"),
         dictgen::InsensitiveStr::Ascii("dies"),
@@ -83810,12 +83810,12 @@ pub static WORD_OVERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_OVERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERP_CHILDREN),
+static WORD_OVERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aied"),
@@ -83851,34 +83851,34 @@ pub static WORD_OVERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OVERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERN_CHILDREN),
+static WORD_OVERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("urfed")],
     values: &[&["overturned"]],
     range: 5..=5,
 };
 
-static WORD_OVERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERM_CHILDREN),
+static WORD_OVERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("apping")],
     values: &[&["overlapping"]],
     range: 6..=6,
 };
 
-static WORD_OVERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERL_CHILDREN),
+static WORD_OVERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anded"),
         dictgen::InsensitiveStr::Ascii("aod"),
@@ -83960,12 +83960,12 @@ pub static WORD_OVERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_OVERK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERK_CHILDREN),
+static WORD_OVERK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERK_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apping"),
         dictgen::InsensitiveStr::Ascii("locked"),
@@ -83974,12 +83974,12 @@ pub static WORD_OVERK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_OVERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERI_CHILDREN),
+static WORD_OVERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ddden"),
         dictgen::InsensitiveStr::Ascii("dden"),
@@ -84003,12 +84003,12 @@ pub static WORD_OVERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_OVERH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERH_CHILDREN),
+static WORD_OVERH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("eading"),
@@ -84050,12 +84050,12 @@ pub static WORD_OVERH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OVERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERF_CHILDREN),
+static WORD_OVERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apping"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -84079,12 +84079,12 @@ pub static WORD_OVERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_OVERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERE_CHILDREN),
+static WORD_OVERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aching"),
         dictgen::InsensitiveStr::Ascii("ngeneer"),
@@ -84104,12 +84104,12 @@ pub static WORD_OVERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=10,
 };
 
-static WORD_OVERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERD_CHILDREN),
+static WORD_OVERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irve"),
         dictgen::InsensitiveStr::Ascii("rev"),
@@ -84118,12 +84118,12 @@ pub static WORD_OVERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_OVERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERC_CHILDREN),
+static WORD_OVERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apping"),
         dictgen::InsensitiveStr::Ascii("haring"),
@@ -84185,12 +84185,12 @@ pub static WORD_OVERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_OVERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERB_CHILDREN),
+static WORD_OVERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aord"),
         dictgen::InsensitiveStr::Ascii("earring"),
@@ -84208,12 +84208,12 @@ pub static WORD_OVERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_OVERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVERA_CHILDREN),
+static WORD_OVERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -84231,12 +84231,12 @@ pub static WORD_OVERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_OVEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVEL_CHILDREN),
+static WORD_OVEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ap"),
         dictgen::InsensitiveStr::Ascii("apping"),
@@ -84245,12 +84245,12 @@ pub static WORD_OVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_OVEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVEF_CHILDREN),
+static WORD_OVEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("low"),
         dictgen::InsensitiveStr::Ascii("lowed"),
@@ -84266,23 +84266,23 @@ pub static WORD_OVEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_OVEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OVEE_CHILDREN),
+static WORD_OVEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OVEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OVEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OVEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("run")],
     values: &[&["overrun"]],
     range: 3..=3,
 };
 
-static WORD_OU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OU_CHILDREN),
+static WORD_OU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OU_CHILDREN),
     value: None,
 };
 
-static WORD_OU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_OUB_NODE),
     None,
@@ -84311,12 +84311,12 @@ static WORD_OU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUU_CHILDREN),
+static WORD_OUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -84325,12 +84325,12 @@ pub static WORD_OUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_OUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OUT_CHILDREN),
+static WORD_OUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OUT_CHILDREN),
     value: None,
 };
 
-static WORD_OUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OUT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OUTA_NODE),
     Some(&WORD_OUTB_NODE),
     Some(&WORD_OUTC_NODE),
@@ -84359,12 +84359,12 @@ static WORD_OUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OUTW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTW_CHILDREN),
+static WORD_OUTW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTW_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eighes"),
         dictgen::InsensitiveStr::Ascii("eight"),
@@ -84380,12 +84380,12 @@ pub static WORD_OUTW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_OUTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTU_CHILDREN),
+static WORD_OUTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pts"),
@@ -84403,12 +84403,12 @@ pub static WORD_OUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_OUTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTT_CHILDREN),
+static WORD_OUTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ermost"),
@@ -84417,12 +84417,12 @@ pub static WORD_OUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_OUTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTS_CHILDREN),
+static WORD_OUTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elves"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -84458,12 +84458,12 @@ pub static WORD_OUTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_OUTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTR_CHILDREN),
+static WORD_OUTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aegously"),
         dictgen::InsensitiveStr::Ascii("ageos"),
@@ -84499,12 +84499,12 @@ pub static WORD_OUTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_OUTP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTP_CHILDREN),
+static WORD_OUTP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alyed"),
         dictgen::InsensitiveStr::Ascii("erfoem"),
@@ -84560,12 +84560,12 @@ pub static WORD_OUTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OUTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTO_CHILDREN),
+static WORD_OUTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ign"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -84579,12 +84579,12 @@ pub static WORD_OUTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_OUTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTN_CHILDREN),
+static WORD_OUTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("umbed"),
         dictgen::InsensitiveStr::Ascii("umberd"),
@@ -84600,12 +84600,12 @@ pub static WORD_OUTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_OUTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTL_CHILDREN),
+static WORD_OUTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cassed"),
         dictgen::InsensitiveStr::Ascii("look"),
@@ -84614,12 +84614,12 @@ pub static WORD_OUTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_OUTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTI_CHILDREN),
+static WORD_OUTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sde"),
         dictgen::InsensitiveStr::Ascii("sder"),
@@ -84629,34 +84629,34 @@ pub static WORD_OUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_OUTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTH_CHILDREN),
+static WORD_OUTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["other", "outer"]],
     range: 2..=2,
 };
 
-static WORD_OUTG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTG_CHILDREN),
+static WORD_OUTG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTG_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oign")],
     values: &[&["outgoing"]],
     range: 4..=4,
 };
 
-static WORD_OUTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTF_CHILDREN),
+static WORD_OUTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eild"),
         dictgen::InsensitiveStr::Ascii("idel"),
@@ -84667,12 +84667,12 @@ pub static WORD_OUTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_OUTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTC_CHILDREN),
+static WORD_OUTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alssed"),
         dictgen::InsensitiveStr::Ascii("lasssed"),
@@ -84681,12 +84681,12 @@ pub static WORD_OUTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_OUTB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTB_CHILDREN),
+static WORD_OUTB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTB_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ut"),
         dictgen::InsensitiveStr::Ascii("uts"),
@@ -84695,23 +84695,23 @@ pub static WORD_OUTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_OUTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUTA_CHILDREN),
+static WORD_OUTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dted")],
     values: &[&["outdated"]],
     range: 4..=4,
 };
 
-static WORD_OUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUS_CHILDREN),
+static WORD_OUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ide"),
         dictgen::InsensitiveStr::Ascii("tanding"),
@@ -84731,12 +84731,12 @@ pub static WORD_OUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_OUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUR_CHILDREN),
+static WORD_OUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("selfe"),
         dictgen::InsensitiveStr::Ascii("selfes"),
@@ -84758,12 +84758,12 @@ pub static WORD_OUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_OUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUP_CHILDREN),
+static WORD_OUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tut"),
         dictgen::InsensitiveStr::Ascii("tuted"),
@@ -84789,23 +84789,23 @@ pub static WORD_OUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_OUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUN_CHILDREN),
+static WORD_OUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tline")],
     values: &[&["outline"]],
     range: 5..=5,
 };
 
-static WORD_OUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUL_CHILDREN),
+static WORD_OUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tinenodes"),
         dictgen::InsensitiveStr::Ascii("tiner"),
@@ -84821,12 +84821,12 @@ pub static WORD_OUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_OUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUE_CHILDREN),
+static WORD_OUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ue"),
@@ -84836,23 +84836,23 @@ pub static WORD_OUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_OUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OUB_CHILDREN),
+static WORD_OUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_OUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lisher")],
     values: &[&["publisher"]],
     range: 6..=6,
 };
 
-static WORD_OT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OT_CHILDREN),
+static WORD_OT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OT_CHILDREN),
     value: Some(&["to", "of", "or", "not"]),
 };
 
-static WORD_OT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OTA_NODE),
     None,
     None,
@@ -84881,34 +84881,34 @@ static WORD_OT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTU_CHILDREN),
+static WORD_OTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTU_CHILDREN),
     value: Some(&["out"]),
 };
 
-pub static WORD_OTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("put")],
     values: &[&["output"]],
     range: 3..=3,
 };
 
-static WORD_OTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTR_CHILDREN),
+static WORD_OTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hographic")],
     values: &[&["orthographic"]],
     range: 9..=9,
 };
 
-static WORD_OTP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTP_CHILDREN),
+static WORD_OTP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -84919,12 +84919,12 @@ pub static WORD_OTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_OTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTI_CHILDREN),
+static WORD_OTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fication"),
         dictgen::InsensitiveStr::Ascii("fications"),
@@ -84948,12 +84948,12 @@ pub static WORD_OTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_OTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTH_CHILDREN),
+static WORD_OTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ere"),
@@ -85045,12 +85045,12 @@ pub static WORD_OTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_OTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTE_CHILDREN),
+static WORD_OTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hr"),
         dictgen::InsensitiveStr::Ascii("hrwice"),
@@ -85074,12 +85074,12 @@ pub static WORD_OTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_OTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OTA_CHILDREN),
+static WORD_OTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -85105,12 +85105,12 @@ pub static WORD_OTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_OS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OS_CHILDREN),
+static WORD_OS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bidian"),
         dictgen::InsensitiveStr::Ascii("bscure"),
@@ -85188,12 +85188,12 @@ pub static WORD_OS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_OR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OR_CHILDREN),
+static WORD_OR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OR_CHILDREN),
     value: None,
 };
 
-static WORD_OR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORA_NODE),
     Some(&WORD_ORB_NODE),
     Some(&WORD_ORC_NODE),
@@ -85222,23 +85222,23 @@ static WORD_OR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ORU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORU_CHILDREN),
+static WORD_ORU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORU_CHILDREN),
     value: Some(&["our"]),
 };
 
-pub static WORD_ORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORT_CHILDREN),
+static WORD_ORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hagnal"),
         dictgen::InsensitiveStr::Ascii("hagonal"),
@@ -85274,23 +85274,23 @@ pub static WORD_ORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=14,
 };
 
-static WORD_ORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORR_CHILDREN),
+static WORD_ORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iginal")],
     values: &[&["original"]],
     range: 6..=6,
 };
 
-static WORD_ORP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORP_CHILDREN),
+static WORD_ORP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahns"),
         dictgen::InsensitiveStr::Ascii("an"),
@@ -85312,23 +85312,23 @@ pub static WORD_ORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ORL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORL_CHILDREN),
+static WORD_ORL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enas")],
     values: &[&["orleans"]],
     range: 4..=4,
 };
 
-static WORD_ORK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORK_CHILDREN),
+static WORD_ORK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("id"),
         dictgen::InsensitiveStr::Ascii("ids"),
@@ -85337,12 +85337,12 @@ pub static WORD_ORK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_ORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ORI_CHILDREN),
+static WORD_ORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ORI_CHILDREN),
     value: None,
 };
 
-static WORD_ORI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ORI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORIA_NODE),
     Some(&WORD_ORIB_NODE),
     Some(&WORD_ORIC_NODE),
@@ -85371,23 +85371,23 @@ static WORD_ORI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ORIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIT_CHILDREN),
+static WORD_ORIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inal")],
     values: &[&["original"]],
     range: 4..=4,
 };
 
-static WORD_ORIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIN_CHILDREN),
+static WORD_ORIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gal"),
         dictgen::InsensitiveStr::Ascii("gally"),
@@ -85397,23 +85397,23 @@ pub static WORD_ORIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ORII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORII_CHILDREN),
+static WORD_ORII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORII_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gn")],
     values: &[&["origin"]],
     range: 2..=2,
 };
 
-static WORD_ORIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIG_CHILDREN),
+static WORD_ORIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("analy"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -85533,12 +85533,12 @@ pub static WORD_ORIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ORIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIE_CHILDREN),
+static WORD_ORIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -85586,12 +85586,12 @@ pub static WORD_ORIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ORID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORID_CHILDREN),
+static WORD_ORID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORID_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inal"),
         dictgen::InsensitiveStr::Ascii("inals"),
@@ -85609,12 +85609,12 @@ pub static WORD_ORID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ORIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIC_CHILDREN),
+static WORD_ORIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("les"),
@@ -85623,23 +85623,23 @@ pub static WORD_ORIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_ORIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIB_CHILDREN),
+static WORD_ORIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tal")],
     values: &[&["orbital"]],
     range: 3..=3,
 };
 
-static WORD_ORIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORIA_CHILDREN),
+static WORD_ORIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("ntate"),
@@ -85655,12 +85655,12 @@ pub static WORD_ORIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORH_CHILDREN),
+static WORD_ORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cestra"),
         dictgen::InsensitiveStr::Ascii("pan"),
@@ -85682,12 +85682,12 @@ pub static WORD_ORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ORG_CHILDREN),
+static WORD_ORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ORG_CHILDREN),
     value: None,
 };
 
-static WORD_ORG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ORG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORGA_NODE),
     None,
     None,
@@ -85716,12 +85716,12 @@ static WORD_ORG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ORGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGN_CHILDREN),
+static WORD_ORGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aisation"),
         dictgen::InsensitiveStr::Ascii("aised"),
@@ -85731,12 +85731,12 @@ pub static WORD_ORGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ORGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGI_CHILDREN),
+static WORD_ORGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ginal"),
         dictgen::InsensitiveStr::Ascii("ginally"),
@@ -85814,12 +85814,12 @@ pub static WORD_ORGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_ORGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ORGA_CHILDREN),
+static WORD_ORGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ORGA_CHILDREN),
     value: None,
 };
 
-static WORD_ORGA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ORGA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -85848,12 +85848,12 @@ static WORD_ORGA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ORGAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGAS_CHILDREN),
+static WORD_ORGAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mes"),
         dictgen::InsensitiveStr::Ascii("mos"),
@@ -85863,12 +85863,12 @@ pub static WORD_ORGAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_ORGAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ORGAN_CHILDREN),
+static WORD_ORGAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ORGAN_CHILDREN),
     value: None,
 };
 
-static WORD_ORGAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ORGAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORGANA_NODE),
     None,
     None,
@@ -85897,12 +85897,12 @@ static WORD_ORGAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_ORGANZ_NODE),
 ];
 
-static WORD_ORGANZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANZ_CHILDREN),
+static WORD_ORGANZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("iation"),
@@ -85932,12 +85932,12 @@ pub static WORD_ORGANZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_ORGANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANS_CHILDREN),
+static WORD_ORGANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iation"),
         dictgen::InsensitiveStr::Ascii("iations"),
@@ -85965,12 +85965,12 @@ pub static WORD_ORGANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_ORGANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANI_CHILDREN),
+static WORD_ORGANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caly"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -86096,12 +86096,12 @@ pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_ORGANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANE_CHILDREN),
+static WORD_ORGANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("red"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -86110,34 +86110,34 @@ pub static WORD_ORGANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_ORGANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGANA_CHILDREN),
+static WORD_ORGANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ize")],
     values: &[&["organize"]],
     range: 3..=3,
 };
 
-static WORD_ORGAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGAM_CHILDREN),
+static WORD_ORGAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ise")],
     values: &[&["organise"]],
     range: 3..=3,
 };
 
-static WORD_ORGAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORGAI_CHILDREN),
+static WORD_ORGAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORGAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORGAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORGAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nizing"),
         dictgen::InsensitiveStr::Ascii("nsation"),
@@ -86159,23 +86159,23 @@ pub static WORD_ORGAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORF_CHILDREN),
+static WORD_ORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["offer", "order"]],
     range: 2..=2,
 };
 
-static WORD_ORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORE_CHILDREN),
+static WORD_ORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -86207,12 +86207,12 @@ pub static WORD_ORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORD_CHILDREN),
+static WORD_ORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("erd"),
@@ -86238,12 +86238,12 @@ pub static WORD_ORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORC_CHILDREN),
+static WORD_ORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -86287,23 +86287,23 @@ pub static WORD_ORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ORB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORB_CHILDREN),
+static WORD_ORB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tial")],
     values: &[&["orbital"]],
     range: 4..=4,
 };
 
-static WORD_ORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ORA_CHILDREN),
+static WORD_ORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cels"),
         dictgen::InsensitiveStr::Ascii("gnered"),
@@ -86339,12 +86339,12 @@ pub static WORD_ORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_OP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OP_CHILDREN),
+static WORD_OP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OP_CHILDREN),
     value: None,
 };
 
-static WORD_OP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OPA_NODE),
     Some(&WORD_OPB_NODE),
     None,
@@ -86373,12 +86373,12 @@ static WORD_OP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPY_CHILDREN),
+static WORD_OPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPY_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -86387,12 +86387,12 @@ pub static WORD_OPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_OPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPU_CHILDREN),
+static WORD_OPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("late"),
         dictgen::InsensitiveStr::Ascii("lates"),
@@ -86406,12 +86406,12 @@ pub static WORD_OPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_OPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OPT_CHILDREN),
+static WORD_OPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OPT_CHILDREN),
     value: None,
 };
 
-static WORD_OPT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OPT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OPTA_NODE),
     None,
     None,
@@ -86440,12 +86440,12 @@ static WORD_OPT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OPTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTO_CHILDREN),
+static WORD_OPTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("inal"),
@@ -86471,12 +86471,12 @@ pub static WORD_OPTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_OPTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTM_CHILDREN),
+static WORD_OPTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isation"),
         dictgen::InsensitiveStr::Ascii("isations"),
@@ -86496,12 +86496,12 @@ pub static WORD_OPTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_OPTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OPTI_CHILDREN),
+static WORD_OPTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OPTI_CHILDREN),
     value: None,
 };
 
-static WORD_OPTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OPTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -86530,34 +86530,34 @@ static WORD_OPTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_OPTIZ_NODE),
 ];
 
-static WORD_OPTIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIZ_CHILDREN),
+static WORD_OPTIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mied")],
     values: &[&["optimized"]],
     range: 4..=4,
 };
 
-static WORD_OPTIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIS_CHILDREN),
+static WORD_OPTIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mied")],
     values: &[&["optimised"]],
     range: 4..=4,
 };
 
-static WORD_OPTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIO_CHILDREN),
+static WORD_OPTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIO_CHILDREN),
     value: Some(&["option"]),
 };
 
-pub static WORD_OPTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anl"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -86603,12 +86603,12 @@ pub static WORD_OPTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_OPTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIN_CHILDREN),
+static WORD_OPTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIN_CHILDREN),
     value: Some(&["option"]),
 };
 
-pub static WORD_OPTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -86618,12 +86618,12 @@ pub static WORD_OPTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_OPTIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTIM_CHILDREN),
+static WORD_OPTIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aal"),
         dictgen::InsensitiveStr::Ascii("asation"),
@@ -86727,23 +86727,23 @@ pub static WORD_OPTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OPTII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTII_CHILDREN),
+static WORD_OPTII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTII_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onal")],
     values: &[&["optional"]],
     range: 4..=4,
 };
 
-static WORD_OPTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTH_CHILDREN),
+static WORD_OPTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("almic"),
         dictgen::InsensitiveStr::Ascii("almologist"),
@@ -86759,12 +86759,12 @@ pub static WORD_OPTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_OPTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTE_CHILDREN),
+static WORD_OPTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ning"),
@@ -86774,12 +86774,12 @@ pub static WORD_OPTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_OPTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPTA_CHILDREN),
+static WORD_OPTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -86790,12 +86790,12 @@ pub static WORD_OPTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_OPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPR_CHILDREN),
+static WORD_OPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -86841,12 +86841,12 @@ pub static WORD_OPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_OPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OPP_CHILDREN),
+static WORD_OPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OPP_CHILDREN),
     value: None,
 };
 
-static WORD_OPP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OPP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -86875,12 +86875,12 @@ static WORD_OPP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OPPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPU_CHILDREN),
+static WORD_OPPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rtinity"),
         dictgen::InsensitiveStr::Ascii("rtunites"),
@@ -86898,23 +86898,23 @@ pub static WORD_OPPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_OPPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPS_CHILDREN),
+static WORD_OPPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPS_CHILDREN),
     value: Some(&["oops"]),
 };
 
-pub static WORD_OPPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ofite")],
     values: &[&["opposite"]],
     range: 5..=5,
 };
 
-static WORD_OPPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPR_CHILDREN),
+static WORD_OPPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essin"),
         dictgen::InsensitiveStr::Ascii("essiun"),
@@ -86940,12 +86940,12 @@ pub static WORD_OPPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_OPPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPP_CHILDREN),
+static WORD_OPPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onent"),
         dictgen::InsensitiveStr::Ascii("ortunity"),
@@ -86955,12 +86955,12 @@ pub static WORD_OPPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_OPPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPO_CHILDREN),
+static WORD_OPPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nant"),
         dictgen::InsensitiveStr::Ascii("nenet"),
@@ -87032,12 +87032,12 @@ pub static WORD_OPPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_OPPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPI_CHILDREN),
+static WORD_OPPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nion"),
         dictgen::InsensitiveStr::Ascii("nions"),
@@ -87047,12 +87047,12 @@ pub static WORD_OPPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_OPPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPPE_CHILDREN),
+static WORD_OPPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nly"),
         dictgen::InsensitiveStr::Ascii("rand"),
@@ -87084,12 +87084,12 @@ pub static WORD_OPPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_OPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPO_CHILDREN),
+static WORD_OPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -87117,12 +87117,12 @@ pub static WORD_OPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_OPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPN_CHILDREN),
+static WORD_OPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -87140,12 +87140,12 @@ pub static WORD_OPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_OPJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPJ_CHILDREN),
+static WORD_OPJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -87177,12 +87177,12 @@ pub static WORD_OPJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_OPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPI_CHILDREN),
+static WORD_OPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("misation"),
         dictgen::InsensitiveStr::Ascii("mized"),
@@ -87260,12 +87260,12 @@ pub static WORD_OPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_OPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPH_CHILDREN),
+static WORD_OPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("talmology"),
@@ -87274,23 +87274,23 @@ pub static WORD_OPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_OPF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPF_CHILDREN),
+static WORD_OPF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPF_CHILDREN),
     value: Some(&["of"]),
 };
 
-pub static WORD_OPF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_OPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OPE_CHILDREN),
+static WORD_OPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OPE_CHILDREN),
     value: None,
 };
 
-static WORD_OPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OPEA_NODE),
     None,
     None,
@@ -87319,12 +87319,12 @@ static WORD_OPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPET_CHILDREN),
+static WORD_OPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -87333,12 +87333,12 @@ pub static WORD_OPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_OPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPER_CHILDREN),
+static WORD_OPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aand"),
         dictgen::InsensitiveStr::Ascii("aands"),
@@ -87448,12 +87448,12 @@ pub static WORD_OPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_OPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEN_CHILDREN),
+static WORD_OPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apig"),
         dictgen::InsensitiveStr::Ascii("brower"),
@@ -87495,12 +87495,12 @@ pub static WORD_OPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_OPEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEM_CHILDREN),
+static WORD_OPEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEM_CHILDREN),
     value: Some(&["open"]),
 };
 
-pub static WORD_OPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ess"),
@@ -87511,12 +87511,12 @@ pub static WORD_OPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_OPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEI_CHILDREN),
+static WORD_OPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("nging"),
@@ -87526,23 +87526,23 @@ pub static WORD_OPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_OPEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEG_CHILDREN),
+static WORD_OPEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEG_CHILDREN),
     value: Some(&["open"]),
 };
 
-pub static WORD_OPEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["opening"]],
     range: 3..=3,
 };
 
-static WORD_OPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPEA_CHILDREN),
+static WORD_OPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("arations"),
@@ -87636,12 +87636,12 @@ pub static WORD_OPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_OPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPB_CHILDREN),
+static WORD_OPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ject"),
         dictgen::InsensitiveStr::Ascii("jective"),
@@ -87651,12 +87651,12 @@ pub static WORD_OPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_OPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OPA_CHILDREN),
+static WORD_OPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctity"),
         dictgen::InsensitiveStr::Ascii("ctiy"),
@@ -87684,12 +87684,12 @@ pub static WORD_OPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_OO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OO_CHILDREN),
+static WORD_OO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mmits"),
         dictgen::InsensitiveStr::Ascii("ur"),
@@ -87701,12 +87701,12 @@ pub static WORD_OO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ON_CHILDREN),
+static WORD_ON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ON_CHILDREN),
     value: None,
 };
 
-static WORD_ON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ONA_NODE),
     Some(&WORD_ONB_NODE),
     Some(&WORD_ONC_NODE),
@@ -87735,23 +87735,23 @@ static WORD_ON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ONY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONY_CHILDREN),
+static WORD_ONY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONY_CHILDREN),
     value: Some(&["only", "on", "one"]),
 };
 
-pub static WORD_ONY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["only"]],
     range: 1..=1,
 };
 
-static WORD_ONW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONW_CHILDREN),
+static WORD_ONW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONW_CHILDREN),
     value: Some(&["own", "now"]),
 };
 
-pub static WORD_ONW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ee"),
@@ -87771,12 +87771,12 @@ pub static WORD_ONW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ONV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONV_CHILDREN),
+static WORD_ONV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eience"),
         dictgen::InsensitiveStr::Ascii("eniently"),
@@ -87786,12 +87786,12 @@ pub static WORD_ONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=8,
 };
 
-static WORD_ONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONT_CHILDREN),
+static WORD_ONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ained"),
@@ -87825,12 +87825,12 @@ pub static WORD_ONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_ONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONS_CHILDREN),
+static WORD_ONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alught"),
         dictgen::InsensitiveStr::Ascii("elf"),
@@ -87850,12 +87850,12 @@ pub static WORD_ONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ONO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONO_CHILDREN),
+static WORD_ONO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONO_CHILDREN),
     value: Some(&["one"]),
 };
 
-pub static WORD_ONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ly"),
         dictgen::InsensitiveStr::Ascii("manopea"),
@@ -87875,23 +87875,23 @@ pub static WORD_ONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONN_CHILDREN),
+static WORD_ONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONN_CHILDREN),
     value: Some(&["on"]),
 };
 
-pub static WORD_ONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ONM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONM_CHILDREN),
+static WORD_ONM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipotent"),
         dictgen::InsensitiveStr::Ascii("iscient"),
@@ -87915,12 +87915,12 @@ pub static WORD_ONM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=9,
 };
 
-static WORD_ONL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONL_CHILDREN),
+static WORD_ONL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONL_CHILDREN),
     value: Some(&["only"]),
 };
 
-pub static WORD_ONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("iene"),
@@ -87942,12 +87942,12 @@ pub static WORD_ONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONG_CHILDREN),
+static WORD_ONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ewild"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -87957,23 +87957,23 @@ pub static WORD_ONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONF_CHILDREN),
+static WORD_ONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("igure")],
     values: &[&["configure"]],
     range: 5..=5,
 };
 
-static WORD_ONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONE_CHILDREN),
+static WORD_ONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("f"),
@@ -87983,23 +87983,23 @@ pub static WORD_ONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_OND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OND_CHILDREN),
+static WORD_OND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OND_CHILDREN),
     value: Some(&["one", "and"]),
 };
 
-pub static WORD_OND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONC_CHILDREN),
+static WORD_ONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("hage"),
@@ -88008,12 +88008,12 @@ pub static WORD_ONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ONB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONB_CHILDREN),
+static WORD_ONB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aord"),
         dictgen::InsensitiveStr::Ascii("orad"),
@@ -88022,23 +88022,23 @@ pub static WORD_ONB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_ONA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ONA_CHILDREN),
+static WORD_ONA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ONA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ONA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("trio")],
     values: &[&["ontario"]],
     range: 4..=4,
 };
 
-static WORD_OM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OM_CHILDREN),
+static WORD_OM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -88158,12 +88158,12 @@ pub static WORD_OM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_OL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OL_CHILDREN),
+static WORD_OL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bigatory"),
         dictgen::InsensitiveStr::Ascii("biterated"),
@@ -88207,12 +88207,12 @@ pub static WORD_OL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_OK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OK_CHILDREN),
+static WORD_OK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OK_CHILDREN),
     value: None,
 };
 
-pub static WORD_OK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("tober"),
@@ -88221,12 +88221,12 @@ pub static WORD_OK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_OJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OJ_CHILDREN),
+static WORD_OJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bect"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -88248,12 +88248,12 @@ pub static WORD_OJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_OI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OI_CHILDREN),
+static WORD_OI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("gin"),
@@ -88281,12 +88281,12 @@ pub static WORD_OI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_OH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OH_CHILDREN),
+static WORD_OH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erwise"),
@@ -88306,12 +88306,12 @@ pub static WORD_OH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_OG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OG_CHILDREN),
+static WORD_OG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OG_CHILDREN),
     value: None,
 };
 
-pub static WORD_OG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anization"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -88335,12 +88335,12 @@ pub static WORD_OG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_OF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OF_CHILDREN),
+static WORD_OF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OF_CHILDREN),
     value: None,
 };
 
-static WORD_OF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_OFC_NODE),
@@ -88369,23 +88369,23 @@ static WORD_OF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFU_CHILDREN),
+static WORD_OFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("scated")],
     values: &[&["obfuscated"]],
     range: 6..=6,
 };
 
-static WORD_OFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFT_CHILDREN),
+static WORD_OFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enly"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -88401,12 +88401,12 @@ pub static WORD_OFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_OFS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFS_CHILDREN),
+static WORD_OFS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etted"),
@@ -88416,12 +88416,12 @@ pub static WORD_OFS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_OFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFR_CHILDREN),
+static WORD_OFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFR_CHILDREN),
     value: Some(&["for"]),
 };
 
-pub static WORD_OFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("om"),
         dictgen::InsensitiveStr::Ascii("ward"),
@@ -88430,23 +88430,23 @@ pub static WORD_OFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_OFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFO_CHILDREN),
+static WORD_OFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFO_CHILDREN),
     value: Some(&["of"]),
 };
 
-pub static WORD_OFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("curse")],
     values: &[&["ofcourse"]],
     range: 5..=5,
 };
 
-static WORD_OFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFI_CHILDREN),
+static WORD_OFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cial"),
@@ -88476,12 +88476,12 @@ pub static WORD_OFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_OFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OFF_CHILDREN),
+static WORD_OFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OFF_CHILDREN),
     value: None,
 };
 
-static WORD_OFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OFF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OFFA_NODE),
     None,
     Some(&WORD_OFFC_NODE),
@@ -88510,34 +88510,34 @@ static WORD_OFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OFFX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFX_CHILDREN),
+static WORD_OFFX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFX_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["offset"]],
     range: 2..=2,
 };
 
-static WORD_OFFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFT_CHILDREN),
+static WORD_OFFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("en")],
     values: &[&["often"]],
     range: 2..=2,
 };
 
-static WORD_OFFS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFS_CHILDREN),
+static WORD_OFFS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ense"),
@@ -88575,34 +88575,34 @@ pub static WORD_OFFS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_OFFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFR_CHILDREN),
+static WORD_OFFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["offered"]],
     range: 2..=2,
 };
 
-static WORD_OFFP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFP_CHILDREN),
+static WORD_OFFP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFP_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sring")],
     values: &[&["offspring"]],
     range: 5..=5,
 };
 
-static WORD_OFFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFL_CHILDREN),
+static WORD_OFFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aod"),
         dictgen::InsensitiveStr::Ascii("aoded"),
@@ -88618,12 +88618,12 @@ pub static WORD_OFFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_OFFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFI_CHILDREN),
+static WORD_OFFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cail"),
@@ -88675,12 +88675,12 @@ pub static WORD_OFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_OFFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFF_CHILDREN),
+static WORD_OFFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ences"),
@@ -88700,12 +88700,12 @@ pub static WORD_OFFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_OFFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFE_CHILDREN),
+static WORD_OFFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ner"),
@@ -88747,12 +88747,12 @@ pub static WORD_OFFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_OFFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFC_CHILDREN),
+static WORD_OFFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -88770,34 +88770,34 @@ pub static WORD_OFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_OFFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFFA_CHILDREN),
+static WORD_OFFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["offset"]],
     range: 2..=2,
 };
 
-static WORD_OFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFE_CHILDREN),
+static WORD_OFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["offer"]],
     range: 1..=1,
 };
 
-static WORD_OFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OFC_CHILDREN),
+static WORD_OFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oruse"),
         dictgen::InsensitiveStr::Ascii("oure"),
@@ -88815,12 +88815,12 @@ pub static WORD_OFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_OE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OE_CHILDREN),
+static WORD_OE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("pnapi"),
@@ -88846,12 +88846,12 @@ pub static WORD_OE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_OD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OD_CHILDREN),
+static WORD_OD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OD_CHILDREN),
     value: None,
 };
 
-pub static WORD_OD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asee"),
         dictgen::InsensitiveStr::Ascii("asees"),
@@ -88873,12 +88873,12 @@ pub static WORD_OD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_OC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OC_CHILDREN),
+static WORD_OC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OC_CHILDREN),
     value: None,
 };
 
-static WORD_OC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OCA_NODE),
     None,
     Some(&WORD_OCC_NODE),
@@ -88907,12 +88907,12 @@ static WORD_OC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCU_CHILDREN),
+static WORD_OCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("ntries"),
@@ -88956,12 +88956,12 @@ pub static WORD_OCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_OCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCT_CHILDREN),
+static WORD_OCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -88989,23 +88989,23 @@ pub static WORD_OCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_OCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCR_CHILDREN),
+static WORD_OCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aina")],
     values: &[&["ocarina"]],
     range: 4..=4,
 };
 
-static WORD_OCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCO_CHILDREN),
+static WORD_OCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rrence"),
         dictgen::InsensitiveStr::Ascii("rrences"),
@@ -89021,12 +89021,12 @@ pub static WORD_OCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_OCN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCN_CHILDREN),
+static WORD_OCN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("figuration"),
@@ -89036,12 +89036,12 @@ pub static WORD_OCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_OCM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCM_CHILDREN),
+static WORD_OCM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCM_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pared"),
         dictgen::InsensitiveStr::Ascii("puted"),
@@ -89050,23 +89050,23 @@ pub static WORD_OCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_OCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCL_CHILDREN),
+static WORD_OCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uded")],
     values: &[&["occluded"]],
     range: 4..=4,
 };
 
-static WORD_OCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCI_CHILDREN),
+static WORD_OCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("late"),
         dictgen::InsensitiveStr::Ascii("lated"),
@@ -89090,34 +89090,34 @@ pub static WORD_OCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_OCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCH_CHILDREN),
+static WORD_OCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("estrating")],
     values: &[&["orchestrating"]],
     range: 9..=9,
 };
 
-static WORD_OCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCE_CHILDREN),
+static WORD_OCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCE_CHILDREN),
     value: Some(&["once", "one", "ore"]),
 };
 
-pub static WORD_OCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_OCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OCC_CHILDREN),
+static WORD_OCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OCC_CHILDREN),
     value: None,
 };
 
-static WORD_OCC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OCC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OCCA_NODE),
     None,
     Some(&WORD_OCCC_NODE),
@@ -89146,12 +89146,12 @@ static WORD_OCC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OCCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCU_CHILDREN),
+static WORD_OCCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cence"),
         dictgen::InsensitiveStr::Ascii("cences"),
@@ -89217,23 +89217,23 @@ pub static WORD_OCCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_OCCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCS_CHILDREN),
+static WORD_OCCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ionally")],
     values: &[&["occasionally"]],
     range: 7..=7,
 };
 
-static WORD_OCCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCR_CHILDREN),
+static WORD_OCCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rance"),
         dictgen::InsensitiveStr::Ascii("rances"),
@@ -89251,12 +89251,12 @@ pub static WORD_OCCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_OCCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCO_CHILDREN),
+static WORD_OCCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rding"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -89278,12 +89278,12 @@ pub static WORD_OCCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_OCCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCC_CHILDREN),
+static WORD_OCCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ur"),
         dictgen::InsensitiveStr::Ascii("ured"),
@@ -89294,12 +89294,12 @@ pub static WORD_OCCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_OCCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCCA_CHILDREN),
+static WORD_OCCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isionally"),
         dictgen::InsensitiveStr::Ascii("ison"),
@@ -89353,12 +89353,12 @@ pub static WORD_OCCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_OCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OCA_CHILDREN),
+static WORD_OCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rnia"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -89394,12 +89394,12 @@ pub static WORD_OCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_OB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_OB_CHILDREN),
+static WORD_OB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_OB_CHILDREN),
     value: None,
 };
 
-static WORD_OB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_OB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_OBA_NODE),
     None,
     Some(&WORD_OBC_NODE),
@@ -89428,12 +89428,12 @@ static WORD_OB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_OBY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBY_CHILDREN),
+static WORD_OBY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBY_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ekt"),
@@ -89442,12 +89442,12 @@ pub static WORD_OBY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=3,
 };
 
-static WORD_OBV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBV_CHILDREN),
+static WORD_OBV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBV_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ersation"),
         dictgen::InsensitiveStr::Ascii("ersations"),
@@ -89481,23 +89481,23 @@ pub static WORD_OBV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_OBU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBU_CHILDREN),
+static WORD_OBU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBU_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sing")],
     values: &[&["abusing"]],
     range: 4..=4,
 };
 
-static WORD_OBT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBT_CHILDREN),
+static WORD_OBT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBT_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aien"),
         dictgen::InsensitiveStr::Ascii("aiend"),
@@ -89541,12 +89541,12 @@ pub static WORD_OBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_OBS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBS_CHILDREN),
+static WORD_OBS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBS_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("colescence"),
         dictgen::InsensitiveStr::Ascii("cruity"),
@@ -89668,23 +89668,23 @@ pub static WORD_OBS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_OBN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBN_CHILDREN),
+static WORD_OBN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBN_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ject")],
     values: &[&["object"]],
     range: 4..=4,
 };
 
-static WORD_OBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBL_CHILDREN),
+static WORD_OBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eek"),
         dictgen::InsensitiveStr::Ascii("eekly"),
@@ -89724,12 +89724,12 @@ pub static WORD_OBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_OBJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBJ_CHILDREN),
+static WORD_OBJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ec"),
         dictgen::InsensitiveStr::Ascii("ecct"),
@@ -89807,12 +89807,12 @@ pub static WORD_OBJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_OBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBI_CHILDREN),
+static WORD_OBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("edence"),
@@ -89840,12 +89840,12 @@ pub static WORD_OBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_OBH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBH_CHILDREN),
+static WORD_OBH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBH_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ectification"),
@@ -89869,12 +89869,12 @@ pub static WORD_OBH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_OBG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBG_CHILDREN),
+static WORD_OBG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBG_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -89883,12 +89883,12 @@ pub static WORD_OBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_OBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBE_CHILDREN),
+static WORD_OBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("diance"),
@@ -89988,34 +89988,34 @@ pub static WORD_OBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_OBD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBD_CHILDREN),
+static WORD_OBD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBD_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("isian")],
     values: &[&["obsidian"]],
     range: 5..=5,
 };
 
-static WORD_OBC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBC_CHILDREN),
+static WORD_OBC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBC_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ject")],
     values: &[&["object"]],
     range: 4..=4,
 };
 
-static WORD_OBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OBA_CHILDREN),
+static WORD_OBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mination"),
         dictgen::InsensitiveStr::Ascii("tinable"),
@@ -90039,12 +90039,12 @@ pub static WORD_OBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_OA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_OA_CHILDREN),
+static WORD_OA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_OA_CHILDREN),
     value: None,
 };
 
-pub static WORD_OA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_OA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ker"),
         dictgen::InsensitiveStr::Ascii("kereous"),
@@ -90072,12 +90072,12 @@ pub static WORD_OA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_N_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_N_CHILDREN),
+static WORD_N_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_N_CHILDREN),
     value: None,
 };
 
-static WORD_N_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_N_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NA_NODE),
     None,
     Some(&WORD_NC_NODE),
@@ -90106,23 +90106,23 @@ static WORD_N_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NY_CHILDREN),
+static WORD_NY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NY_CHILDREN),
     value: None,
 };
 
-pub static WORD_NY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mber")],
     values: &[&["number"]],
     range: 4..=4,
 };
 
-static WORD_NW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NW_CHILDREN),
+static WORD_NW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -90131,12 +90131,12 @@ pub static WORD_NW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=1,
 };
 
-static WORD_NV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NV_CHILDREN),
+static WORD_NV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ironment"),
@@ -90145,12 +90145,12 @@ pub static WORD_NV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_NU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NU_CHILDREN),
+static WORD_NU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NU_CHILDREN),
     value: None,
 };
 
-static WORD_NU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NUA_NODE),
     Some(&WORD_NUB_NODE),
     Some(&WORD_NUC_NODE),
@@ -90179,12 +90179,12 @@ static WORD_NU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUT_CHILDREN),
+static WORD_NUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irent"),
         dictgen::InsensitiveStr::Ascii("irents"),
@@ -90240,12 +90240,12 @@ pub static WORD_NUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_NUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUS_CHILDREN),
+static WORD_NUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aince"),
         dictgen::InsensitiveStr::Ascii("ance"),
@@ -90255,12 +90255,12 @@ pub static WORD_NUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUR_CHILDREN),
+static WORD_NUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emburg"),
         dictgen::InsensitiveStr::Ascii("ish"),
@@ -90288,12 +90288,12 @@ pub static WORD_NUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_NUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUN_CHILDREN),
+static WORD_NUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("bers"),
@@ -90303,12 +90303,12 @@ pub static WORD_NUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_NUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUM_CHILDREN),
+static WORD_NUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bber"),
         dictgen::InsensitiveStr::Ascii("bbered"),
@@ -90412,12 +90412,12 @@ pub static WORD_NUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_NUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUL_CHILDREN),
+static WORD_NUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("cear"),
@@ -90445,12 +90445,12 @@ pub static WORD_NUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_NUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUI_CHILDREN),
+static WORD_NUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sans"),
         dictgen::InsensitiveStr::Ascii("sanse"),
@@ -90466,12 +90466,12 @@ pub static WORD_NUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_NUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUE_CHILDREN),
+static WORD_NUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rological"),
         dictgen::InsensitiveStr::Ascii("rons"),
@@ -90493,12 +90493,12 @@ pub static WORD_NUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_NUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUC_CHILDREN),
+static WORD_NUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elar"),
         dictgen::InsensitiveStr::Ascii("elus"),
@@ -90520,12 +90520,12 @@ pub static WORD_NUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUB_CHILDREN),
+static WORD_NUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ering"),
@@ -90536,12 +90536,12 @@ pub static WORD_NUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_NUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NUA_CHILDREN),
+static WORD_NUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghty"),
         dictgen::InsensitiveStr::Ascii("tilus"),
@@ -90550,12 +90550,12 @@ pub static WORD_NUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NT_CHILDREN),
+static WORD_NT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ification"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -90564,12 +90564,12 @@ pub static WORD_NT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_NS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NS_CHILDREN),
+static WORD_NS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tall"),
         dictgen::InsensitiveStr::Ascii("tallation"),
@@ -90589,12 +90589,12 @@ pub static WORD_NS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_NR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NR_CHILDREN),
+static WORD_NR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eferenced"),
         dictgen::InsensitiveStr::Ascii("ivana"),
@@ -90605,12 +90605,12 @@ pub static WORD_NR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_NO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NO_CHILDREN),
+static WORD_NO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NO_CHILDREN),
     value: None,
 };
 
-static WORD_NO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_NOB_NODE),
     Some(&WORD_NOC_NODE),
@@ -90639,23 +90639,23 @@ static WORD_NO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOY_CHILDREN),
+static WORD_NOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOY_CHILDREN),
     value: Some(&["not"]),
 };
 
-pub static WORD_NOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_NOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOW_CHILDREN),
+static WORD_NOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adys"),
         dictgen::InsensitiveStr::Ascii("days"),
@@ -90673,12 +90673,12 @@ pub static WORD_NOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_NOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOV_CHILDREN),
+static WORD_NOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eau"),
         dictgen::InsensitiveStr::Ascii("embeard"),
@@ -90706,12 +90706,12 @@ pub static WORD_NOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_NOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NOT_CHILDREN),
+static WORD_NOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NOT_CHILDREN),
     value: None,
 };
 
-static WORD_NOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NOT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NOTA_NODE),
     Some(&WORD_NOTB_NODE),
     Some(&WORD_NOTC_NODE),
@@ -90740,23 +90740,23 @@ static WORD_NOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NOTW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTW_CHILDREN),
+static WORD_NOTW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hithstanding")],
     values: &[&["notwithstanding"]],
     range: 12..=12,
 };
 
-static WORD_NOTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTT_CHILDREN),
+static WORD_NOTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTT_CHILDREN),
     value: Some(&["not"]),
 };
 
-pub static WORD_NOTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aion"),
         dictgen::InsensitiveStr::Ascii("aions"),
@@ -90765,23 +90765,23 @@ pub static WORD_NOTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_NOTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTS_CHILDREN),
+static WORD_NOTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["notes", "note"]],
     range: 1..=1,
 };
 
-static WORD_NOTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTO_CHILDREN),
+static WORD_NOTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("focation"),
@@ -90815,23 +90815,23 @@ pub static WORD_NOTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_NOTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTN_CHILDREN),
+static WORD_NOTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["nothing"]],
     range: 3..=3,
 };
 
-static WORD_NOTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTM_CHILDREN),
+static WORD_NOTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alize"),
         dictgen::InsensitiveStr::Ascii("alized"),
@@ -90842,12 +90842,12 @@ pub static WORD_NOTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_NOTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NOTI_CHILDREN),
+static WORD_NOTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NOTI_CHILDREN),
     value: None,
 };
 
-static WORD_NOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NOTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_NOTIC_NODE),
@@ -90876,12 +90876,12 @@ static WORD_NOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NOTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIT_CHILDREN),
+static WORD_NOTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifers"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -90890,23 +90890,23 @@ pub static WORD_NOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_NOTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIR_CHILDREN),
+static WORD_NOTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ications")],
     values: &[&["notifications"]],
     range: 8..=8,
 };
 
-static WORD_NOTIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIG_CHILDREN),
+static WORD_NOTIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -90915,12 +90915,12 @@ pub static WORD_NOTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_NOTIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIF_CHILDREN),
+static WORD_NOTIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acation"),
         dictgen::InsensitiveStr::Ascii("acations"),
@@ -91014,23 +91014,23 @@ pub static WORD_NOTIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_NOTID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTID_CHILDREN),
+static WORD_NOTID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTID_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["notify"]],
     range: 1..=1,
 };
 
-static WORD_NOTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTIC_CHILDREN),
+static WORD_NOTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("abely"),
@@ -91070,12 +91070,12 @@ pub static WORD_NOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_NOTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTH_CHILDREN),
+static WORD_NOTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTH_CHILDREN),
     value: Some(&["north"]),
 };
 
-pub static WORD_NOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ern"),
@@ -91103,12 +91103,12 @@ pub static WORD_NOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_NOTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTF_CHILDREN),
+static WORD_NOTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -91118,12 +91118,12 @@ pub static WORD_NOTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_NOTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTE_CHILDREN),
+static WORD_NOTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ably"),
@@ -91149,34 +91149,34 @@ pub static WORD_NOTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_NOTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTC_CHILDREN),
+static WORD_NOTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iable")],
     values: &[&["noticeable"]],
     range: 5..=5,
 };
 
-static WORD_NOTB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTB_CHILDREN),
+static WORD_NOTB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eooks")],
     values: &[&["notebooks"]],
     range: 5..=5,
 };
 
-static WORD_NOTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOTA_CHILDREN),
+static WORD_NOTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bley"),
         dictgen::InsensitiveStr::Ascii("blly"),
@@ -91200,12 +91200,12 @@ pub static WORD_NOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_NOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOS_CHILDREN),
+static WORD_NOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("taglia"),
         dictgen::InsensitiveStr::Ascii("taglic"),
@@ -91249,12 +91249,12 @@ pub static WORD_NOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_NOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NOR_CHILDREN),
+static WORD_NOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NOR_CHILDREN),
     value: None,
 };
 
-static WORD_NOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NORA_NODE),
     None,
     None,
@@ -91283,12 +91283,12 @@ static WORD_NOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NORW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORW_CHILDREN),
+static WORD_NORW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egain"),
         dictgen::InsensitiveStr::Ascii("egin"),
@@ -91298,12 +91298,12 @@ pub static WORD_NORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_NORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORT_CHILDREN),
+static WORD_NORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heat"),
         dictgen::InsensitiveStr::Ascii("hen"),
@@ -91335,23 +91335,23 @@ pub static WORD_NORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_NORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORN_CHILDREN),
+static WORD_NORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["normal"]],
     range: 2..=2,
 };
 
-static WORD_NORM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORM_CHILDREN),
+static WORD_NORM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailzation"),
         dictgen::InsensitiveStr::Ascii("aized"),
@@ -91425,23 +91425,23 @@ pub static WORD_NORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_NORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORI_CHILDREN),
+static WORD_NORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fications")],
     values: &[&["notifications"]],
     range: 9..=9,
 };
 
-static WORD_NORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORH_CHILDREN),
+static WORD_NORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ern"),
         dictgen::InsensitiveStr::Ascii("teast"),
@@ -91459,23 +91459,23 @@ pub static WORD_NORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_NORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORE_CHILDREN),
+static WORD_NORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORE_CHILDREN),
     value: Some(&["nor", "more", "node", "note"]),
 };
 
-pub static WORD_NORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_NORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NORA_CHILDREN),
+static WORD_NORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lize"),
@@ -91517,34 +91517,34 @@ pub static WORD_NORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_NOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOP_CHILDREN),
+static WORD_NOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tifying")],
     values: &[&["notifying"]],
     range: 7..=7,
 };
 
-static WORD_NOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOO_CHILDREN),
+static WORD_NOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOO_CHILDREN),
     value: Some(&["no"]),
 };
 
-pub static WORD_NOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_NON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NON_CHILDREN),
+static WORD_NON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NON_CHILDREN),
     value: None,
 };
 
-pub static WORD_NON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("combatents"),
         dictgen::InsensitiveStr::Ascii("deteministic"),
@@ -91596,12 +91596,12 @@ pub static WORD_NON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_NOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOM_CHILDREN),
+static WORD_NOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("bered"),
@@ -91643,12 +91643,12 @@ pub static WORD_NOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_NOJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOJ_CHILDREN),
+static WORD_NOJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ification"),
         dictgen::InsensitiveStr::Ascii("ifications"),
@@ -91657,12 +91657,12 @@ pub static WORD_NOJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=10,
 };
 
-static WORD_NOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOI_CHILDREN),
+static WORD_NOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ser"),
@@ -91672,34 +91672,34 @@ pub static WORD_NOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_NOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOH_CHILDREN),
+static WORD_NOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ypen")],
     values: &[&["nohyphen"]],
     range: 4..=4,
 };
 
-static WORD_NOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOG_CHILDREN),
+static WORD_NOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ht")],
     values: &[&["night"]],
     range: 2..=2,
 };
 
-static WORD_NOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOF_CHILDREN),
+static WORD_NOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -91715,23 +91715,23 @@ pub static WORD_NOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_NOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOE_CHILDREN),
+static WORD_NOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOE_CHILDREN),
     value: Some(&["not", "no", "node", "know", "now", "note"]),
 };
 
-pub static WORD_NOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("xistent")],
     values: &[&["nonexistent"]],
     range: 7..=7,
 };
 
-static WORD_NOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOD_CHILDREN),
+static WORD_NOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("els"),
@@ -91749,12 +91749,12 @@ pub static WORD_NOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_NOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOC_CHILDREN),
+static WORD_NOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ontinuable"),
         dictgen::InsensitiveStr::Ascii("trune"),
@@ -91772,12 +91772,12 @@ pub static WORD_NOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_NOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NOB_CHILDREN),
+static WORD_NOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ady"),
         dictgen::InsensitiveStr::Ascii("oday"),
@@ -91786,12 +91786,12 @@ pub static WORD_NOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_NN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NN_CHILDREN),
+static WORD_NN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eeded"),
@@ -91813,12 +91813,12 @@ pub static WORD_NN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_NM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NM_CHILDREN),
+static WORD_NM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("emonic"),
@@ -91828,23 +91828,23 @@ pub static WORD_NM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_NL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NL_CHILDREN),
+static WORD_NL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["only"]],
     range: 1..=1,
 };
 
-static WORD_NK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NK_CHILDREN),
+static WORD_NK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NK_CHILDREN),
     value: None,
 };
 
-pub static WORD_NK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nown"),
         dictgen::InsensitiveStr::Ascii("ow"),
@@ -91854,12 +91854,12 @@ pub static WORD_NK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_NI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NI_CHILDREN),
+static WORD_NI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NI_CHILDREN),
     value: None,
 };
 
-static WORD_NI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NIA_NODE),
     Some(&WORD_NIB_NODE),
     Some(&WORD_NIC_NODE),
@@ -91888,12 +91888,12 @@ static WORD_NI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIV_CHILDREN),
+static WORD_NIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erse"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -91907,23 +91907,23 @@ pub static WORD_NIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_NIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIU_CHILDREN),
+static WORD_NIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sance")],
     values: &[&["nuisance"]],
     range: 5..=5,
 };
 
-static WORD_NIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIT_CHILDREN),
+static WORD_NIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -91949,12 +91949,12 @@ pub static WORD_NIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_NIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIR_CHILDREN),
+static WORD_NIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("togen"),
         dictgen::InsensitiveStr::Ascii("vanna"),
@@ -91963,34 +91963,34 @@ pub static WORD_NIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_NIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIP_CHILDREN),
+static WORD_NIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ticking")],
     values: &[&["nitpicking"]],
     range: 7..=7,
 };
 
-static WORD_NIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIO_CHILDREN),
+static WORD_NIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["not"]],
     range: 1..=1,
 };
 
-static WORD_NIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIN_CHILDREN),
+static WORD_NIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIN_CHILDREN),
     value: Some(&["inn", "min", "bin", "nine"]),
 };
 
-pub static WORD_NIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eth"),
         dictgen::InsensitiveStr::Ascii("ima"),
@@ -92018,12 +92018,12 @@ pub static WORD_NIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_NIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIM_CHILDREN),
+static WORD_NIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ations"),
         dictgen::InsensitiveStr::Ascii("ph"),
@@ -92059,23 +92059,23 @@ pub static WORD_NIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_NIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIL_CHILDREN),
+static WORD_NIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ihism")],
     values: &[&["nihilism"]],
     range: 5..=5,
 };
 
-static WORD_NIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIH_CHILDREN),
+static WORD_NIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilim"),
         dictgen::InsensitiveStr::Ascii("ilisim"),
@@ -92086,12 +92086,12 @@ pub static WORD_NIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_NIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIG_CHILDREN),
+static WORD_NIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hbor"),
         dictgen::InsensitiveStr::Ascii("hborhood"),
@@ -92143,12 +92143,12 @@ pub static WORD_NIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_NIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIF_CHILDREN),
+static WORD_NIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -92157,12 +92157,12 @@ pub static WORD_NIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_NIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIE_CHILDREN),
+static WORD_NIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("arest"),
@@ -92198,12 +92198,12 @@ pub static WORD_NIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_NIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIC_CHILDREN),
+static WORD_NIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kame"),
         dictgen::InsensitiveStr::Ascii("kanme"),
@@ -92213,45 +92213,45 @@ pub static WORD_NIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIB_CHILDREN),
+static WORD_NIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mle")],
     values: &[&["nimble"]],
     range: 3..=3,
 };
 
-static WORD_NIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NIA_CHILDREN),
+static WORD_NIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ve")],
     values: &[&["naive"]],
     range: 2..=2,
 };
 
-static WORD_NF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NF_CHILDREN),
+static WORD_NF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ormation")],
     values: &[&["information"]],
     range: 8..=8,
 };
 
-static WORD_NE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NE_CHILDREN),
+static WORD_NE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NE_CHILDREN),
     value: None,
 };
 
-static WORD_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEA_NODE),
     None,
     Some(&WORD_NEC_NODE),
@@ -92280,12 +92280,12 @@ static WORD_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEX_CHILDREN),
+static WORD_NEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essary"),
         dictgen::InsensitiveStr::Ascii("ting"),
@@ -92295,12 +92295,12 @@ pub static WORD_NEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_NEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEW_CHILDREN),
+static WORD_NEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("anced"),
@@ -92372,12 +92372,12 @@ pub static WORD_NEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_NEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEV_CHILDREN),
+static WORD_NEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elop"),
         dictgen::InsensitiveStr::Ascii("elope"),
@@ -92411,12 +92411,12 @@ pub static WORD_NEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_NEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEU_CHILDREN),
+static WORD_NEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meric"),
         dictgen::InsensitiveStr::Ascii("monectomies"),
@@ -92478,12 +92478,12 @@ pub static WORD_NEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_NET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NET_CHILDREN),
+static WORD_NET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NET_CHILDREN),
     value: None,
 };
 
-pub static WORD_NET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acpe"),
         dictgen::InsensitiveStr::Ascii("boook"),
@@ -92535,12 +92535,12 @@ pub static WORD_NET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_NES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NES_CHILDREN),
+static WORD_NES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NES_CHILDREN),
     value: None,
 };
 
-pub static WORD_NES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cesaries"),
         dictgen::InsensitiveStr::Ascii("cesarily"),
@@ -92618,12 +92618,12 @@ pub static WORD_NES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_NER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NER_CHILDREN),
+static WORD_NER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NER_CHILDREN),
     value: None,
 };
 
-pub static WORD_NER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -92661,23 +92661,23 @@ pub static WORD_NER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_NEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEP_CHILDREN),
+static WORD_NEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tun")],
     values: &[&["neptune"]],
     range: 3..=3,
 };
 
-static WORD_NEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEO_CHILDREN),
+static WORD_NEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("litic"),
         dictgen::InsensitiveStr::Ascii("roscience"),
@@ -92686,34 +92686,34 @@ pub static WORD_NEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_NEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEN_CHILDREN),
+static WORD_NEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("viroment")],
     values: &[&["environment"]],
     range: 8..=8,
 };
 
-static WORD_NEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEL_CHILDREN),
+static WORD_NEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ink")],
     values: &[&["netlink"]],
     range: 3..=3,
 };
 
-static WORD_NEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEI_CHILDREN),
+static WORD_NEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEI_CHILDREN),
     value: None,
 };
 
-static WORD_NEI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_NEIB_NODE),
     Some(&WORD_NEIC_NODE),
@@ -92742,23 +92742,23 @@ static WORD_NEI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIT_CHILDREN),
+static WORD_NEIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["neither"]],
     range: 2..=2,
 };
 
-static WORD_NEIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEIG_CHILDREN),
+static WORD_NEIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEIG_CHILDREN),
     value: None,
 };
 
-static WORD_NEIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEIG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_NEIGB_NODE),
     None,
@@ -92787,23 +92787,23 @@ static WORD_NEIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGT_CHILDREN),
+static WORD_NEIGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("her")],
     values: &[&["neither"]],
     range: 3..=3,
 };
 
-static WORD_NEIGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEIGH_CHILDREN),
+static WORD_NEIGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEIGH_CHILDREN),
     value: None,
 };
 
-static WORD_NEIGH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEIGH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_NEIGHB_NODE),
     None,
@@ -92832,12 +92832,12 @@ static WORD_NEIGH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIGHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHT_CHILDREN),
+static WORD_NEIGHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHT_CHILDREN),
     value: Some(&["neither"]),
 };
 
-pub static WORD_NEIGHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bor"),
         dictgen::InsensitiveStr::Ascii("borhood"),
@@ -92877,12 +92877,12 @@ pub static WORD_NEIGHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_NEIGHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHR_CHILDREN),
+static WORD_NEIGHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orhood"),
@@ -92910,12 +92910,12 @@ pub static WORD_NEIGHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_NEIGHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHO_CHILDREN),
+static WORD_NEIGHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("br"),
         dictgen::InsensitiveStr::Ascii("brhood"),
@@ -92953,23 +92953,23 @@ pub static WORD_NEIGHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_NEIGHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHE_CHILDREN),
+static WORD_NEIGHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["neither"]],
     range: 1..=1,
 };
 
-static WORD_NEIGHB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEIGHB_CHILDREN),
+static WORD_NEIGHB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEIGHB_CHILDREN),
     value: None,
 };
 
-static WORD_NEIGHB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEIGHB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEIGHBA_NODE),
     Some(&WORD_NEIGHBB_NODE),
     None,
@@ -92998,12 +92998,12 @@ static WORD_NEIGHB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIGHBU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBU_CHILDREN),
+static WORD_NEIGHBU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rhood"),
@@ -93021,12 +93021,12 @@ pub static WORD_NEIGHBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_NEIGHBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBR_CHILDREN),
+static WORD_NEIGHBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBR_CHILDREN),
     value: Some(&["neighbor"]),
 };
 
-pub static WORD_NEIGHBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ohood"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -93035,12 +93035,12 @@ pub static WORD_NEIGHBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_NEIGHBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEIGHBO_CHILDREN),
+static WORD_NEIGHBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEIGHBO_CHILDREN),
     value: None,
 };
 
-static WORD_NEIGHBO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEIGHBO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEIGHBOA_NODE),
     None,
     None,
@@ -93069,12 +93069,12 @@ static WORD_NEIGHBO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEIGHBOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOU_CHILDREN),
+static WORD_NEIGHBOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("rbood"),
@@ -93142,12 +93142,12 @@ pub static WORD_NEIGHBOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_NEIGHBOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOT_CHILDREN),
+static WORD_NEIGHBOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOT_CHILDREN),
     value: Some(&["neighbor"]),
 };
 
-pub static WORD_NEIGHBOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hood"),
         dictgen::InsensitiveStr::Ascii("hoods"),
@@ -93157,23 +93157,23 @@ pub static WORD_NEIGHBOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=5,
 };
 
-static WORD_NEIGHBOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOS_CHILDREN),
+static WORD_NEIGHBOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOS_CHILDREN),
     value: Some(&["neighbors"]),
 };
 
-pub static WORD_NEIGHBOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_NEIGHBOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOR_CHILDREN),
+static WORD_NEIGHBOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ds"),
         dictgen::InsensitiveStr::Ascii("ehood"),
@@ -93227,12 +93227,12 @@ pub static WORD_NEIGHBOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=7,
 };
 
-static WORD_NEIGHBOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOO_CHILDREN),
+static WORD_NEIGHBOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -93264,23 +93264,23 @@ pub static WORD_NEIGHBOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=7,
 };
 
-static WORD_NEIGHBOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOI_CHILDREN),
+static WORD_NEIGHBOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["neighboring"]],
     range: 2..=2,
 };
 
-static WORD_NEIGHBOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOH_CHILDREN),
+static WORD_NEIGHBOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ood"),
         dictgen::InsensitiveStr::Ascii("oods"),
@@ -93289,12 +93289,12 @@ pub static WORD_NEIGHBOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 3..=4,
 };
 
-static WORD_NEIGHBOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOA_CHILDREN),
+static WORD_NEIGHBOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rds"),
@@ -93303,12 +93303,12 @@ pub static WORD_NEIGHBOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=3,
 };
 
-static WORD_NEIGHBH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBH_CHILDREN),
+static WORD_NEIGHBH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orhood"),
@@ -93326,12 +93326,12 @@ pub static WORD_NEIGHBH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=7,
 };
 
-static WORD_NEIGHBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBE_CHILDREN),
+static WORD_NEIGHBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -93453,12 +93453,12 @@ pub static WORD_NEIGHBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_NEIGHBB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBB_CHILDREN),
+static WORD_NEIGHBB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orhood"),
@@ -93476,12 +93476,12 @@ pub static WORD_NEIGHBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=7,
 };
 
-static WORD_NEIGHBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBA_CHILDREN),
+static WORD_NEIGHBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGHBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGHBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGHBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rhood"),
@@ -93499,12 +93499,12 @@ pub static WORD_NEIGHBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_NEIGB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIGB_CHILDREN),
+static WORD_NEIGB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIGB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIGB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIGB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hor"),
         dictgen::InsensitiveStr::Ascii("horhood"),
@@ -93542,23 +93542,23 @@ pub static WORD_NEIGB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_NEIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIC_CHILDREN),
+static WORD_NEIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["niece", "nice"]],
     range: 1..=1,
 };
 
-static WORD_NEIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEIB_CHILDREN),
+static WORD_NEIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hbors"),
         dictgen::InsensitiveStr::Ascii("hbours"),
@@ -93578,12 +93578,12 @@ pub static WORD_NEIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_NEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEG_CHILDREN),
+static WORD_NEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEG_CHILDREN),
     value: None,
 };
 
-static WORD_NEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGA_NODE),
     None,
     None,
@@ -93612,23 +93612,23 @@ static WORD_NEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGT_CHILDREN),
+static WORD_NEGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ive")],
     values: &[&["negative"]],
     range: 3..=3,
 };
 
-static WORD_NEGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEGO_CHILDREN),
+static WORD_NEGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEGO_CHILDREN),
     value: None,
 };
 
-static WORD_NEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEGO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGOA_NODE),
     None,
     Some(&WORD_NEGOC_NODE),
@@ -93657,12 +93657,12 @@ static WORD_NEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGOZ_NODE),
 ];
 
-static WORD_NEGOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOZ_CHILDREN),
+static WORD_NEGOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -93688,12 +93688,12 @@ pub static WORD_NEGOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEGOT_CHILDREN),
+static WORD_NEGOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEGOT_CHILDREN),
     value: None,
 };
 
-static WORD_NEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEGOT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGOTA_NODE),
     None,
     None,
@@ -93722,12 +93722,12 @@ static WORD_NEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEGOTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEGOTI_CHILDREN),
+static WORD_NEGOTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEGOTI_CHILDREN),
     value: None,
 };
 
-static WORD_NEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEGOTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NEGOTIA_NODE),
     Some(&WORD_NEGOTIB_NODE),
     Some(&WORD_NEGOTIC_NODE),
@@ -93756,12 +93756,12 @@ static WORD_NEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NEGOTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIT_CHILDREN),
+static WORD_NEGOTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -93819,12 +93819,12 @@ pub static WORD_NEGOTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_NEGOTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIO_CHILDREN),
+static WORD_NEGOTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -93908,23 +93908,23 @@ pub static WORD_NEGOTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_NEGOTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIN_CHILDREN),
+static WORD_NEGOTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ate")],
     values: &[&["negotiate"]],
     range: 3..=3,
 };
 
-static WORD_NEGOTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIC_CHILDREN),
+static WORD_NEGOTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -93950,23 +93950,23 @@ pub static WORD_NEGOTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=6,
 };
 
-static WORD_NEGOTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIB_CHILDREN),
+static WORD_NEGOTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["negotiable"]],
     range: 2..=2,
 };
 
-static WORD_NEGOTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIA_CHILDREN),
+static WORD_NEGOTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ning"),
@@ -93998,12 +93998,12 @@ pub static WORD_NEGOTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=5,
 };
 
-static WORD_NEGOTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTH_CHILDREN),
+static WORD_NEGOTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -94029,12 +94029,12 @@ pub static WORD_NEGOTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_NEGOTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTA_CHILDREN),
+static WORD_NEGOTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -94126,12 +94126,12 @@ pub static WORD_NEGOTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_NEGOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOS_CHILDREN),
+static WORD_NEGOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -94157,12 +94157,12 @@ pub static WORD_NEGOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOP_CHILDREN),
+static WORD_NEGOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tionsotiable"),
         dictgen::InsensitiveStr::Ascii("tionsotiate"),
@@ -94188,12 +94188,12 @@ pub static WORD_NEGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 11..=14,
 };
 
-static WORD_NEGOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOI_CHILDREN),
+static WORD_NEGOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tate"),
@@ -94219,12 +94219,12 @@ pub static WORD_NEGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOG_CHILDREN),
+static WORD_NEGOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iated"),
         dictgen::InsensitiveStr::Ascii("tiable"),
@@ -94252,12 +94252,12 @@ pub static WORD_NEGOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_NEGOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOC_CHILDREN),
+static WORD_NEGOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -94283,12 +94283,12 @@ pub static WORD_NEGOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGOA_CHILDREN),
+static WORD_NEGOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("te"),
@@ -94332,12 +94332,12 @@ pub static WORD_NEGOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_NEGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGL_CHILDREN),
+static WORD_NEGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGL_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acting"),
         dictgen::InsensitiveStr::Ascii("agence"),
@@ -94383,12 +94383,12 @@ pub static WORD_NEGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_NEGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGI_CHILDREN),
+static WORD_NEGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("lgence"),
@@ -94426,12 +94426,12 @@ pub static WORD_NEGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_NEGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGE_CHILDREN),
+static WORD_NEGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("lcting"),
@@ -94441,12 +94441,12 @@ pub static WORD_NEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_NEGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEGA_CHILDREN),
+static WORD_NEGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ive"),
         dictgen::InsensitiveStr::Ascii("rive"),
@@ -94494,23 +94494,23 @@ pub static WORD_NEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_NEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEF_CHILDREN),
+static WORD_NEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arios")],
     values: &[&["nefarious"]],
     range: 5..=5,
 };
 
-static WORD_NEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEE_CHILDREN),
+static WORD_NEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("deed"),
@@ -94566,12 +94566,12 @@ pub static WORD_NEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_NED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NED_CHILDREN),
+static WORD_NED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NED_CHILDREN),
     value: Some(&["need", "end"]),
 };
 
-pub static WORD_NED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -94601,12 +94601,12 @@ pub static WORD_NED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_NEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NEC_CHILDREN),
+static WORD_NEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NEC_CHILDREN),
     value: None,
 };
 
-static WORD_NEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NECA_NODE),
     None,
     Some(&WORD_NECC_NODE),
@@ -94635,23 +94635,23 @@ static WORD_NEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECT_CHILDREN),
+static WORD_NECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECT_CHILDREN),
     value: Some(&["next"]),
 };
 
-pub static WORD_NECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ode")],
     values: &[&["netcode"]],
     range: 3..=3,
 };
 
-static WORD_NECS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECS_CHILDREN),
+static WORD_NECS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sarily"),
         dictgen::InsensitiveStr::Ascii("sary"),
@@ -94660,12 +94660,12 @@ pub static WORD_NECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_NECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECR_CHILDREN),
+static WORD_NECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omacer"),
         dictgen::InsensitiveStr::Ascii("omamcer"),
@@ -94683,12 +94683,12 @@ pub static WORD_NECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_NECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECO_CHILDREN),
+static WORD_NECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nstitutional"),
         dictgen::InsensitiveStr::Ascii("rmancer"),
@@ -94697,12 +94697,12 @@ pub static WORD_NECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=12,
 };
 
-static WORD_NECK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECK_CHILDREN),
+static WORD_NECK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECK_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bead"),
         dictgen::InsensitiveStr::Ascii("bearders"),
@@ -94738,23 +94738,23 @@ pub static WORD_NECK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_NECH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECH_CHILDREN),
+static WORD_NECH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("anism")],
     values: &[&["mechanism"]],
     range: 5..=5,
 };
 
-static WORD_NECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECE_CHILDREN),
+static WORD_NECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("assary"),
         dictgen::InsensitiveStr::Ascii("sarily"),
@@ -94832,12 +94832,12 @@ pub static WORD_NECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_NECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECC_CHILDREN),
+static WORD_NECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecarily"),
         dictgen::InsensitiveStr::Ascii("ecary"),
@@ -94869,12 +94869,12 @@ pub static WORD_NECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_NECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NECA_CHILDREN),
+static WORD_NECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ssary"),
         dictgen::InsensitiveStr::Ascii("ssery"),
@@ -94885,12 +94885,12 @@ pub static WORD_NECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_NEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NEA_CHILDREN),
+static WORD_NEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -94922,12 +94922,12 @@ pub static WORD_NEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ND_CHILDREN),
+static WORD_ND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ND_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efined"),
         dictgen::InsensitiveStr::Ascii("erline"),
@@ -94938,12 +94938,12 @@ pub static WORD_ND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_NC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NC_CHILDREN),
+static WORD_NC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("essarily"),
@@ -94963,12 +94963,12 @@ pub static WORD_NC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_NA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NA_CHILDREN),
+static WORD_NA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NA_CHILDREN),
     value: None,
 };
 
-static WORD_NA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_NAA_NODE),
     None,
     Some(&WORD_NAC_NODE),
@@ -94997,12 +94997,12 @@ static WORD_NA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_NAZ_NODE),
 ];
 
-static WORD_NAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAZ_CHILDREN),
+static WORD_NAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ereth"),
         dictgen::InsensitiveStr::Ascii("ionalists"),
@@ -95011,12 +95011,12 @@ pub static WORD_NAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_NAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAY_CHILDREN),
+static WORD_NAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bhor"),
         dictgen::InsensitiveStr::Ascii("bhorhood"),
@@ -95056,12 +95056,12 @@ pub static WORD_NAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_NAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAX_CHILDREN),
+static WORD_NAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAX_CHILDREN),
     value: Some(&["max", "nad"]),
 };
 
-pub static WORD_NAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ima"),
         dictgen::InsensitiveStr::Ascii("imal"),
@@ -95071,12 +95071,12 @@ pub static WORD_NAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_NAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAW_CHILDREN),
+static WORD_NAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sea"),
         dictgen::InsensitiveStr::Ascii("seous"),
@@ -95100,12 +95100,12 @@ pub static WORD_NAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_NAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAV_CHILDREN),
+static WORD_NAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agate"),
         dictgen::InsensitiveStr::Ascii("agating"),
@@ -95153,12 +95153,12 @@ pub static WORD_NAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_NAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAU_CHILDREN),
+static WORD_NAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esous"),
         dictgen::InsensitiveStr::Ascii("ghtly"),
@@ -95190,12 +95190,12 @@ pub static WORD_NAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_NAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_NAT_CHILDREN),
+static WORD_NAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_NAT_CHILDREN),
     value: None,
 };
 
-static WORD_NAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_NAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_NATC_NODE),
@@ -95224,23 +95224,23 @@ static WORD_NAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_NATV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATV_CHILDREN),
+static WORD_NATV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATV_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("igation")],
     values: &[&["navigation"]],
     range: 7..=7,
 };
 
-static WORD_NATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATU_CHILDREN),
+static WORD_NATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATU_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arally"),
         dictgen::InsensitiveStr::Ascii("ilus"),
@@ -95264,12 +95264,12 @@ pub static WORD_NATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_NATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATR_CHILDREN),
+static WORD_NATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ual"),
         dictgen::InsensitiveStr::Ascii("ually"),
@@ -95278,12 +95278,12 @@ pub static WORD_NATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_NATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATI_CHILDREN),
+static WORD_NATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("evly"),
         dictgen::InsensitiveStr::Ascii("nal"),
@@ -95415,12 +95415,12 @@ pub static WORD_NATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_NATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NATC_CHILDREN),
+static WORD_NATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NATC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hed"),
         dictgen::InsensitiveStr::Ascii("hes"),
@@ -95429,12 +95429,12 @@ pub static WORD_NATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_NAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAS_CHILDREN),
+static WORD_NAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euous"),
         dictgen::InsensitiveStr::Ascii("hvile"),
@@ -95498,12 +95498,12 @@ pub static WORD_NAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_NAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAR_CHILDREN),
+static WORD_NAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("cassism"),
@@ -95619,12 +95619,12 @@ pub static WORD_NAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_NAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAP_CHILDREN),
+static WORD_NAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cakes"),
         dictgen::InsensitiveStr::Ascii("loeon"),
@@ -95664,23 +95664,23 @@ pub static WORD_NAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_NAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAO_CHILDREN),
+static WORD_NAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pleon")],
     values: &[&["napoleon"]],
     range: 5..=5,
 };
 
-static WORD_NAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAN_CHILDREN),
+static WORD_NAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("osecod"),
@@ -95704,12 +95704,12 @@ pub static WORD_NAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_NAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAM_CHILDREN),
+static WORD_NAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAM_CHILDREN),
     value: Some(&["name"]),
 };
 
-pub static WORD_NAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aed"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -95773,12 +95773,12 @@ pub static WORD_NAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_NAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAI_CHILDREN),
+static WORD_NAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bhor"),
         dictgen::InsensitiveStr::Ascii("bhorhood"),
@@ -95810,23 +95810,23 @@ pub static WORD_NAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_NAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAH_CHILDREN),
+static WORD_NAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sville")],
     values: &[&["nashville"]],
     range: 6..=6,
 };
 
-static WORD_NAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAG_CHILDREN),
+static WORD_NAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("atively"),
@@ -95846,23 +95846,23 @@ pub static WORD_NAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_NAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAF_CHILDREN),
+static WORD_NAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erious")],
     values: &[&["nefarious"]],
     range: 6..=6,
 };
 
-static WORD_NAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAE_CHILDREN),
+static WORD_NAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("rly"),
@@ -95871,23 +95871,23 @@ pub static WORD_NAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_NAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAD_CHILDREN),
+static WORD_NAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["badly"]],
     range: 2..=2,
 };
 
-static WORD_NAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAC_CHILDREN),
+static WORD_NAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ionalistic"),
         dictgen::InsensitiveStr::Ascii("ionalists"),
@@ -95897,23 +95897,23 @@ pub static WORD_NAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=10,
 };
 
-static WORD_NAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_NAA_CHILDREN),
+static WORD_NAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_NAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_NAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_NAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("me")],
     values: &[&["name"]],
     range: 2..=2,
 };
 
-static WORD_M_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_M_CHILDREN),
+static WORD_M_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_M_CHILDREN),
     value: None,
 };
 
-static WORD_M_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_M_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MA_NODE),
     None,
     Some(&WORD_MC_NODE),
@@ -95942,12 +95942,12 @@ static WORD_M_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MY_CHILDREN),
+static WORD_MY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abe"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -96029,34 +96029,34 @@ pub static WORD_MY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_MW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MW_CHILDREN),
+static WORD_MW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MW_CHILDREN),
     value: None,
 };
 
-pub static WORD_MW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cos")],
     values: &[&["macos"]],
     range: 3..=3,
 };
 
-static WORD_MV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MV_CHILDREN),
+static WORD_MV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oes")],
     values: &[&["moves"]],
     range: 3..=3,
 };
 
-static WORD_MU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MU_CHILDREN),
+static WORD_MU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MU_CHILDREN),
     value: None,
 };
 
-static WORD_MU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_MUC_NODE),
@@ -96085,23 +96085,23 @@ static WORD_MU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MUY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUY_CHILDREN),
+static WORD_MUY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("st")],
     values: &[&["must"]],
     range: 2..=2,
 };
 
-static WORD_MUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUT_CHILDREN),
+static WORD_MUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ablility"),
         dictgen::InsensitiveStr::Ascii("ablity"),
@@ -96235,12 +96235,12 @@ pub static WORD_MUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_MUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUS_CHILDREN),
+static WORD_MUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cel"),
         dictgen::InsensitiveStr::Ascii("cels"),
@@ -96314,12 +96314,12 @@ pub static WORD_MUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_MUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUR_CHILDREN),
+static WORD_MUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("derd"),
         dictgen::InsensitiveStr::Ascii("dererd"),
@@ -96343,12 +96343,12 @@ pub static WORD_MUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUN_CHILDREN),
+static WORD_MUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bers"),
         dictgen::InsensitiveStr::Ascii("chis"),
@@ -96378,12 +96378,12 @@ pub static WORD_MUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_MUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUM_CHILDREN),
+static WORD_MUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("bers"),
@@ -96392,12 +96392,12 @@ pub static WORD_MUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_MUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MUL_CHILDREN),
+static WORD_MUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MUL_CHILDREN),
     value: None,
 };
 
-static WORD_MUL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MUL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -96426,12 +96426,12 @@ static WORD_MUL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MULT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MULT_CHILDREN),
+static WORD_MULT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MULT_CHILDREN),
     value: None,
 };
 
-static WORD_MULT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MULT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -96460,12 +96460,12 @@ static WORD_MULT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MULTY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTY_CHILDREN),
+static WORD_MULTY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTY_CHILDREN),
     value: Some(&["multi"]),
 };
 
-pub static WORD_MULTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("player"),
         dictgen::InsensitiveStr::Ascii("plying"),
@@ -96474,12 +96474,12 @@ pub static WORD_MULTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_MULTP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTP_CHILDREN),
+static WORD_MULTP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("art"),
         dictgen::InsensitiveStr::Ascii("ile"),
@@ -96507,12 +96507,12 @@ pub static WORD_MULTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MULTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTL_CHILDREN),
+static WORD_MULTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("iple"),
@@ -96538,12 +96538,12 @@ pub static WORD_MULTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MULTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MULTI_CHILDREN),
+static WORD_MULTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MULTI_CHILDREN),
     value: None,
 };
 
-static WORD_MULTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MULTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_MULTIB_NODE),
     Some(&WORD_MULTIC_NODE),
@@ -96572,23 +96572,23 @@ static WORD_MULTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MULTIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIX_CHILDREN),
+static WORD_MULTIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("site")],
     values: &[&["multisite"]],
     range: 4..=4,
 };
 
-static WORD_MULTIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIV_CHILDREN),
+static WORD_MULTIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erese"),
         dictgen::InsensitiveStr::Ascii("riate"),
@@ -96597,12 +96597,12 @@ pub static WORD_MULTIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=5,
 };
 
-static WORD_MULTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIT_CHILDREN),
+static WORD_MULTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aking"),
         dictgen::InsensitiveStr::Ascii("aksing"),
@@ -96622,23 +96622,23 @@ pub static WORD_MULTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_MULTIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIS_CHILDREN),
+static WORD_MULTIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mapling")],
     values: &[&["multisampling"]],
     range: 7..=7,
 };
 
-static WORD_MULTIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIP_CHILDREN),
+static WORD_MULTIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alyer"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -96730,12 +96730,12 @@ pub static WORD_MULTIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_MULTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIN_CHILDREN),
+static WORD_MULTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atinal"),
         dictgen::InsensitiveStr::Ascii("ationella"),
@@ -96745,23 +96745,23 @@ pub static WORD_MULTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_MULTIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIM_CHILDREN),
+static WORD_MULTIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ational")],
     values: &[&["multinational"]],
     range: 7..=7,
 };
 
-static WORD_MULTIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIL_CHILDREN),
+static WORD_MULTIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angual"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -96777,34 +96777,34 @@ pub static WORD_MULTIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_MULTIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIF_CHILDREN),
+static WORD_MULTIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uction")],
     values: &[&["multifunction"]],
     range: 6..=6,
 };
 
-static WORD_MULTIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIE_CHILDREN),
+static WORD_MULTIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cast")],
     values: &[&["multicast"]],
     range: 4..=4,
 };
 
-static WORD_MULTID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTID_CHILDREN),
+static WORD_MULTID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTID_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imensinal"),
         dictgen::InsensitiveStr::Ascii("imension"),
@@ -96820,12 +96820,12 @@ pub static WORD_MULTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 8..=11,
 };
 
-static WORD_MULTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIC_CHILDREN),
+static WORD_MULTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ultralism"),
@@ -96834,12 +96834,12 @@ pub static WORD_MULTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_MULTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULTIB_CHILDREN),
+static WORD_MULTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("ye"),
@@ -96848,34 +96848,34 @@ pub static WORD_MULTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=2,
 };
 
-static WORD_MULS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULS_CHILDREN),
+static WORD_MULS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ims")],
     values: &[&["muslims"]],
     range: 3..=3,
 };
 
-static WORD_MULL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULL_CHILDREN),
+static WORD_MULL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tiple")],
     values: &[&["multiple"]],
     range: 5..=5,
 };
 
-static WORD_MULI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MULI_CHILDREN),
+static WORD_MULI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MULI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MULI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MULI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("part"),
         dictgen::InsensitiveStr::Ascii("ple"),
@@ -96937,23 +96937,23 @@ pub static WORD_MULI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_MUK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUK_CHILDREN),
+static WORD_MUK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("titasking")],
     values: &[&["multitasking"]],
     range: 9..=9,
 };
 
-static WORD_MUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUI_CHILDREN),
+static WORD_MUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ltiple"),
         dictgen::InsensitiveStr::Ascii("ltiples"),
@@ -96962,23 +96962,23 @@ pub static WORD_MUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_MUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUH_CHILDREN),
+static WORD_MUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUH_CHILDREN),
     value: Some(&["much"]),
 };
 
-pub static WORD_MUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("c")],
     values: &[&["much"]],
     range: 1..=1,
 };
 
-static WORD_MUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUF_CHILDREN),
+static WORD_MUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fings"),
         dictgen::InsensitiveStr::Ascii("finus"),
@@ -96987,12 +96987,12 @@ pub static WORD_MUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_MUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUE_CHILDREN),
+static WORD_MUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sums"),
         dictgen::InsensitiveStr::Ascii("xt"),
@@ -97001,12 +97001,12 @@ pub static WORD_MUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_MUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUD_CHILDREN),
+static WORD_MUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ering"),
@@ -97017,12 +97017,12 @@ pub static WORD_MUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MUC_CHILDREN),
+static WORD_MUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MUC_CHILDREN),
     value: Some(&["much"]),
 };
 
-pub static WORD_MUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isians"),
         dictgen::InsensitiveStr::Ascii("nhies"),
@@ -97032,12 +97032,12 @@ pub static WORD_MUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_MT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MT_CHILDREN),
+static WORD_MT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hod"),
         dictgen::InsensitiveStr::Ascii("hods"),
@@ -97047,12 +97047,12 @@ pub static WORD_MT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_MS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MS_CHILDREN),
+static WORD_MS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ot"),
         dictgen::InsensitiveStr::Ascii("sing"),
@@ -97063,12 +97063,12 @@ pub static WORD_MS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_MR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MR_CHILDREN),
+static WORD_MR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oe"),
         dictgen::InsensitiveStr::Ascii("oning"),
@@ -97077,12 +97077,12 @@ pub static WORD_MR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MP_CHILDREN),
+static WORD_MP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ortant"),
@@ -97091,12 +97091,12 @@ pub static WORD_MP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_MO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MO_CHILDREN),
+static WORD_MO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MO_CHILDREN),
     value: None,
 };
 
-static WORD_MO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MOA_NODE),
     Some(&WORD_MOB_NODE),
     Some(&WORD_MOC_NODE),
@@ -97125,12 +97125,12 @@ static WORD_MO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MOZ_NODE),
 ];
 
-static WORD_MOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOZ_CHILDREN),
+static WORD_MOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iila"),
         dictgen::InsensitiveStr::Ascii("ila"),
@@ -97156,12 +97156,12 @@ pub static WORD_MOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_MOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOV_CHILDREN),
+static WORD_MOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebackwrd"),
         dictgen::InsensitiveStr::Ascii("eble"),
@@ -97221,12 +97221,12 @@ pub static WORD_MOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_MOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOU_CHILDREN),
+static WORD_MOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dle"),
         dictgen::InsensitiveStr::Ascii("dles"),
@@ -97294,12 +97294,12 @@ pub static WORD_MOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOT_CHILDREN),
+static WORD_MOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("eef"),
@@ -97407,12 +97407,12 @@ pub static WORD_MOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_MOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOS_CHILDREN),
+static WORD_MOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("iturizer"),
@@ -97454,12 +97454,12 @@ pub static WORD_MOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_MOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOR_CHILDREN),
+static WORD_MOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOR_CHILDREN),
     value: Some(&["more"]),
 };
 
-pub static WORD_MOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atlity"),
         dictgen::InsensitiveStr::Ascii("bidley"),
@@ -97577,12 +97577,12 @@ pub static WORD_MOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_MOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOP_CHILDREN),
+static WORD_MOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dule"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -97592,12 +97592,12 @@ pub static WORD_MOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOO_CHILDREN),
+static WORD_MOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dify"),
         dictgen::InsensitiveStr::Ascii("nligt"),
@@ -97607,12 +97607,12 @@ pub static WORD_MOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_MON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MON_CHILDREN),
+static WORD_MON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MON_CHILDREN),
     value: None,
 };
 
-static WORD_MON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MONA_NODE),
     None,
     Some(&WORD_MONC_NODE),
@@ -97641,23 +97641,23 @@ static WORD_MON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MONY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONY_CHILDREN),
+static WORD_MONY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONY_CHILDREN),
     value: Some(&["money"]),
 };
 
-pub static WORD_MONY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_MONU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONU_CHILDREN),
+static WORD_MONU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mentaal"),
         dictgen::InsensitiveStr::Ascii("mentais"),
@@ -97685,12 +97685,12 @@ pub static WORD_MONU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONT_CHILDREN),
+static WORD_MONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aban"),
         dictgen::InsensitiveStr::Ascii("aeg"),
@@ -97748,12 +97748,12 @@ pub static WORD_MONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_MONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONS_CHILDREN),
+static WORD_MONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("day"),
         dictgen::InsensitiveStr::Ascii("errat"),
@@ -97789,12 +97789,12 @@ pub static WORD_MONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MONR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONR_CHILDREN),
+static WORD_MONR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achy"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -97803,12 +97803,12 @@ pub static WORD_MONR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MONO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONO_CHILDREN),
+static WORD_MONO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chome"),
         dictgen::InsensitiveStr::Ascii("chorome"),
@@ -97906,12 +97906,12 @@ pub static WORD_MONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_MONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONN_CHILDREN),
+static WORD_MONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("th"),
         dictgen::InsensitiveStr::Ascii("ths"),
@@ -97920,23 +97920,23 @@ pub static WORD_MONN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MONK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONK_CHILDREN),
+static WORD_MONK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["monkeys"]],
     range: 3..=3,
 };
 
-static WORD_MONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONI_CHILDREN),
+static WORD_MONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("tary"),
@@ -97966,12 +97966,12 @@ pub static WORD_MONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONG_CHILDREN),
+static WORD_MONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("los"),
         dictgen::InsensitiveStr::Ascii("oles"),
@@ -97981,12 +97981,12 @@ pub static WORD_MONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONE_CHILDREN),
+static WORD_MONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONE_CHILDREN),
     value: Some(&["mono", "money", "none"]),
 };
 
-pub static WORD_MONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("staries"),
         dictgen::InsensitiveStr::Ascii("stary"),
@@ -98002,34 +98002,34 @@ pub static WORD_MONE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_MOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOND_CHILDREN),
+static WORD_MOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ey")],
     values: &[&["monday", "money", "monkey"]],
     range: 2..=2,
 };
 
-static WORD_MONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONC_CHILDREN),
+static WORD_MONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hrome")],
     values: &[&["monochrome"]],
     range: 5..=5,
 };
 
-static WORD_MONA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MONA_CHILDREN),
+static WORD_MONA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MONA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MONA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gomous"),
         dictgen::InsensitiveStr::Ascii("gomy"),
@@ -98051,12 +98051,12 @@ pub static WORD_MONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_MOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOM_CHILDREN),
+static WORD_MOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ementarily"),
@@ -98118,12 +98118,12 @@ pub static WORD_MOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_MOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOL_CHILDREN),
+static WORD_MOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eclues"),
         dictgen::InsensitiveStr::Ascii("eculair"),
@@ -98161,12 +98161,12 @@ pub static WORD_MOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_MOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOI_CHILDREN),
+static WORD_MOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bles"),
@@ -98208,12 +98208,12 @@ pub static WORD_MOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOH_CHILDREN),
+static WORD_MOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ammedan"),
         dictgen::InsensitiveStr::Ascii("ammedans"),
@@ -98222,12 +98222,12 @@ pub static WORD_MOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_MOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOF_CHILDREN),
+static WORD_MOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dified"),
         dictgen::InsensitiveStr::Ascii("ification"),
@@ -98247,12 +98247,12 @@ pub static WORD_MOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_MOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOE_CHILDREN),
+static WORD_MOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lcules"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -98270,12 +98270,12 @@ pub static WORD_MOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_MOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MOD_CHILDREN),
+static WORD_MOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MOD_CHILDREN),
     value: None,
 };
 
-static WORD_MOD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MOD_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -98304,12 +98304,12 @@ static WORD_MOD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MODY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODY_CHILDREN),
+static WORD_MODY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fing"),
         dictgen::InsensitiveStr::Ascii("fy"),
@@ -98319,12 +98319,12 @@ pub static WORD_MODY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MODU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODU_CHILDREN),
+static WORD_MODU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alr"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -98356,23 +98356,23 @@ pub static WORD_MODU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_MODT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODT_CHILDREN),
+static WORD_MODT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ified")],
     values: &[&["modified"]],
     range: 5..=5,
 };
 
-static WORD_MODP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODP_CHILDREN),
+static WORD_MODP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("robbing"),
         dictgen::InsensitiveStr::Ascii("robeing"),
@@ -98381,12 +98381,12 @@ pub static WORD_MODP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_MODL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODL_CHILDREN),
+static WORD_MODL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -98402,12 +98402,12 @@ pub static WORD_MODL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_MODI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MODI_CHILDREN),
+static WORD_MODI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MODI_CHILDREN),
     value: None,
 };
 
-static WORD_MODI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MODI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_MODIC_NODE),
@@ -98436,56 +98436,56 @@ static WORD_MODI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MODIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIY_CHILDREN),
+static WORD_MODIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["modifying"]],
     range: 3..=3,
 };
 
-static WORD_MODIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIV_CHILDREN),
+static WORD_MODIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ational")],
     values: &[&["motivational"]],
     range: 7..=7,
 };
 
-static WORD_MODIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIR_CHILDREN),
+static WORD_MODIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["moderation"]],
     range: 5..=5,
 };
 
-static WORD_MODIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIO_CHILDREN),
+static WORD_MODIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fication")],
     values: &[&["modification"]],
     range: 8..=8,
 };
 
-static WORD_MODIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIL_CHILDREN),
+static WORD_MODIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -98494,12 +98494,12 @@ pub static WORD_MODIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_MODII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODII_CHILDREN),
+static WORD_MODII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODII_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("fier"),
@@ -98509,12 +98509,12 @@ pub static WORD_MODII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MODIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIF_CHILDREN),
+static WORD_MODIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("action"),
@@ -98632,12 +98632,12 @@ pub static WORD_MODIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_MODID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODID_CHILDREN),
+static WORD_MODID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODID_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fication"),
         dictgen::InsensitiveStr::Ascii("fications"),
@@ -98661,12 +98661,12 @@ pub static WORD_MODID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MODIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODIC_CHILDREN),
+static WORD_MODIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -98675,12 +98675,12 @@ pub static WORD_MODIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_MODF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODF_CHILDREN),
+static WORD_MODF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -98766,12 +98766,12 @@ pub static WORD_MODF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_MODE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODE_CHILDREN),
+static WORD_MODE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -98829,12 +98829,12 @@ pub static WORD_MODE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_MODD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MODD_CHILDREN),
+static WORD_MODD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MODD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MODD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MODD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("eled"),
@@ -98852,12 +98852,12 @@ pub static WORD_MODD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_MOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOC_CHILDREN),
+static WORD_MOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rochip"),
         dictgen::InsensitiveStr::Ascii("rochips"),
@@ -98897,12 +98897,12 @@ pub static WORD_MOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=14,
 };
 
-static WORD_MOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOB_CHILDREN),
+static WORD_MOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ify"),
         dictgen::InsensitiveStr::Ascii("ilitiy"),
@@ -98913,23 +98913,23 @@ pub static WORD_MOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_MOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MOA_CHILDREN),
+static WORD_MOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("st")],
     values: &[&["most", "moat"]],
     range: 2..=2,
 };
 
-static WORD_MN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MN_CHILDREN),
+static WORD_MN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("emnonic"),
@@ -98947,12 +98947,12 @@ pub static WORD_MN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_MM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MM_CHILDREN),
+static WORD_MM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anifest"),
         dictgen::InsensitiveStr::Ascii("aped"),
@@ -98972,12 +98972,12 @@ pub static WORD_MM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_MK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MK_CHILDREN),
+static WORD_MK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -98989,23 +98989,23 @@ pub static WORD_MK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_MJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MJ_CHILDREN),
+static WORD_MJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("or")],
     values: &[&["major"]],
     range: 2..=2,
 };
 
-static WORD_MI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MI_CHILDREN),
+static WORD_MI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MI_CHILDREN),
     value: None,
 };
 
-static WORD_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MIA_NODE),
     None,
     Some(&WORD_MIC_NODE),
@@ -99034,12 +99034,12 @@ static WORD_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIX_CHILDREN),
+static WORD_MIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imum"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -99057,12 +99057,12 @@ pub static WORD_MIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_MIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIT_CHILDREN),
+static WORD_MIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gate"),
         dictgen::InsensitiveStr::Ascii("icate"),
@@ -99088,12 +99088,12 @@ pub static WORD_MIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_MIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MIS_CHILDREN),
+static WORD_MIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MIS_CHILDREN),
     value: Some(&["miss", "mist"]),
 };
 
-static WORD_MIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MIS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MISA_NODE),
     Some(&WORD_MISB_NODE),
     Some(&WORD_MISC_NODE),
@@ -99122,12 +99122,12 @@ static WORD_MIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MISY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISY_CHILDREN),
+static WORD_MISY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gonist"),
         dictgen::InsensitiveStr::Ascii("gonistic"),
@@ -99136,12 +99136,12 @@ pub static WORD_MISY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_MISU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISU_CHILDREN),
+static WORD_MISU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bderstanding"),
         dictgen::InsensitiveStr::Ascii("dnerstanding"),
@@ -99223,12 +99223,12 @@ pub static WORD_MISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=14,
 };
 
-static WORD_MIST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIST_CHILDREN),
+static WORD_MIST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIST_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("akedly"),
         dictgen::InsensitiveStr::Ascii("akengly"),
@@ -99298,12 +99298,12 @@ pub static WORD_MIST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_MISS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MISS_CHILDREN),
+static WORD_MISS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MISS_CHILDREN),
     value: None,
 };
 
-static WORD_MISS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MISS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MISSA_NODE),
     None,
     Some(&WORD_MISSC_NODE),
@@ -99332,12 +99332,12 @@ static WORD_MISS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MISSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSU_CHILDREN),
+static WORD_MISSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nderstanding"),
         dictgen::InsensitiveStr::Ascii("nderstood"),
@@ -99355,12 +99355,12 @@ pub static WORD_MISSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_MISST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISST_CHILDREN),
+static WORD_MISST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISST_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ake"),
         dictgen::InsensitiveStr::Ascii("aken"),
@@ -99378,23 +99378,23 @@ pub static WORD_MISST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MISSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSS_CHILDREN),
+static WORD_MISSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["missing"]],
     range: 3..=3,
 };
 
-static WORD_MISSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSP_CHILDREN),
+static WORD_MISSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eeling"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -99420,12 +99420,12 @@ pub static WORD_MISSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MISSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSO_CHILDREN),
+static WORD_MISSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nary"),
         dictgen::InsensitiveStr::Ascii("rui"),
@@ -99435,23 +99435,23 @@ pub static WORD_MISSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MISSN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSN_CHILDREN),
+static WORD_MISSN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["missing"]],
     range: 1..=1,
 };
 
-static WORD_MISSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSM_CHILDREN),
+static WORD_MISSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anaged"),
         dictgen::InsensitiveStr::Ascii("atch"),
@@ -99471,12 +99471,12 @@ pub static WORD_MISSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_MISSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSL_CHILDREN),
+static WORD_MISSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eading"),
@@ -99487,12 +99487,12 @@ pub static WORD_MISSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_MISSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSI_CHILDREN),
+static WORD_MISSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("gno"),
@@ -99544,12 +99544,12 @@ pub static WORD_MISSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_MISSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSE_CHILDREN),
+static WORD_MISSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nce"),
@@ -99558,12 +99558,12 @@ pub static WORD_MISSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_MISSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSC_CHILDREN),
+static WORD_MISSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lassified"),
         dictgen::InsensitiveStr::Ascii("lassifies"),
@@ -99589,12 +99589,12 @@ pub static WORD_MISSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=12,
 };
 
-static WORD_MISSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISSA_CHILDREN),
+static WORD_MISSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("lignment"),
@@ -99603,12 +99603,12 @@ pub static WORD_MISSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_MISR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISR_CHILDREN),
+static WORD_MISR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eable"),
         dictgen::InsensitiveStr::Ascii("eably"),
@@ -99640,12 +99640,12 @@ pub static WORD_MISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=13,
 };
 
-static WORD_MISQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISQ_CHILDREN),
+static WORD_MISQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uito"),
         dictgen::InsensitiveStr::Ascii("uitos"),
@@ -99654,12 +99654,12 @@ pub static WORD_MISQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_MISP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISP_CHILDREN),
+static WORD_MISP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ell"),
         dictgen::InsensitiveStr::Ascii("elled"),
@@ -99681,12 +99681,12 @@ pub static WORD_MISP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=13,
 };
 
-static WORD_MISO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISO_CHILDREN),
+static WORD_MISO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ganist"),
         dictgen::InsensitiveStr::Ascii("ganistic"),
@@ -99748,23 +99748,23 @@ pub static WORD_MISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_MISN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISN_CHILDREN),
+static WORD_MISN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("adry")],
     values: &[&["misandry"]],
     range: 4..=4,
 };
 
-static WORD_MISM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISM_CHILDREN),
+static WORD_MISM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -99786,12 +99786,12 @@ pub static WORD_MISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_MISL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISL_CHILDREN),
+static WORD_MISL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abaled"),
         dictgen::InsensitiveStr::Ascii("abled"),
@@ -99805,12 +99805,12 @@ pub static WORD_MISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_MISI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISI_CHILDREN),
+static WORD_MISI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("mformed"),
@@ -99896,12 +99896,12 @@ pub static WORD_MISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_MISG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISG_CHILDREN),
+static WORD_MISG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oynist"),
         dictgen::InsensitiveStr::Ascii("oynistic"),
@@ -99910,12 +99910,12 @@ pub static WORD_MISG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_MISF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISF_CHILDREN),
+static WORD_MISF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ormed"),
         dictgen::InsensitiveStr::Ascii("ortunte"),
@@ -99931,12 +99931,12 @@ pub static WORD_MISF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_MISE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISE_CHILDREN),
+static WORD_MISE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laneous"),
         dictgen::InsensitiveStr::Ascii("laneously"),
@@ -99960,12 +99960,12 @@ pub static WORD_MISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_MISD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISD_CHILDREN),
+static WORD_MISD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ameanor"),
         dictgen::InsensitiveStr::Ascii("ameanors"),
@@ -99993,12 +99993,12 @@ pub static WORD_MISD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_MISC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISC_CHILDREN),
+static WORD_MISC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("airrage"),
         dictgen::InsensitiveStr::Ascii("allenaous"),
@@ -100076,23 +100076,23 @@ pub static WORD_MISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=12,
 };
 
-static WORD_MISB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISB_CHILDREN),
+static WORD_MISB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ehaive")],
     values: &[&["misbehave"]],
     range: 6..=6,
 };
 
-static WORD_MISA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MISA_CHILDREN),
+static WORD_MISA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MISA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MISA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ke"),
         dictgen::InsensitiveStr::Ascii("ken"),
@@ -100120,12 +100120,12 @@ pub static WORD_MISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIR_CHILDREN),
+static WORD_MIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acalous"),
         dictgen::InsensitiveStr::Ascii("acilously"),
@@ -100233,23 +100233,23 @@ pub static WORD_MIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=14,
 };
 
-static WORD_MIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIP_CHILDREN),
+static WORD_MIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lementation")],
     values: &[&["implementation"]],
     range: 11..=11,
 };
 
-static WORD_MIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MIN_CHILDREN),
+static WORD_MIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MIN_CHILDREN),
     value: None,
 };
 
-static WORD_MIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MINA_NODE),
     None,
     None,
@@ -100278,12 +100278,12 @@ static WORD_MIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MINU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINU_CHILDREN),
+static WORD_MINU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -100311,12 +100311,12 @@ pub static WORD_MINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_MINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINT_CHILDREN),
+static WORD_MINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("ored"),
@@ -100336,12 +100336,12 @@ pub static WORD_MINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINS_CHILDREN),
+static WORD_MINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icule"),
         dictgen::InsensitiveStr::Ascii("iter"),
@@ -100361,12 +100361,12 @@ pub static WORD_MINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MINO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINO_CHILDREN),
+static WORD_MINO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ins"),
         dictgen::InsensitiveStr::Ascii("osha"),
@@ -100382,12 +100382,12 @@ pub static WORD_MINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_MINN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINN_CHILDREN),
+static WORD_MINN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eaoplis"),
         dictgen::InsensitiveStr::Ascii("eaplis"),
@@ -100417,12 +100417,12 @@ pub static WORD_MINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_MINM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINM_CHILDREN),
+static WORD_MINM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ize"),
@@ -100432,12 +100432,12 @@ pub static WORD_MINM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MINI_CHILDREN),
+static WORD_MINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MINI_CHILDREN),
     value: None,
 };
 
-static WORD_MINI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MINI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MINIA_NODE),
     None,
     None,
@@ -100466,12 +100466,12 @@ static WORD_MINI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MINIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIU_CHILDREN),
+static WORD_MINIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("ms"),
@@ -100481,12 +100481,12 @@ pub static WORD_MINIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_MINIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIT_CHILDREN),
+static WORD_MINIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ature"),
         dictgen::InsensitiveStr::Ascii("aure"),
@@ -100502,12 +100502,12 @@ pub static WORD_MINIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MINIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIS_CHILDREN),
+static WORD_MINIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clue"),
         dictgen::InsensitiveStr::Ascii("cue"),
@@ -100539,12 +100539,12 @@ pub static WORD_MINIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_MINIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIP_CHILDREN),
+static WORD_MINIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ulating"),
         dictgen::InsensitiveStr::Ascii("ulation"),
@@ -100554,12 +100554,12 @@ pub static WORD_MINIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_MININ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MININ_CHILDREN),
+static WORD_MININ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MININ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MININ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MININ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alist"),
@@ -100595,12 +100595,12 @@ pub static WORD_MININ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_MINIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIM_CHILDREN),
+static WORD_MINIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("alisitc"),
@@ -100664,34 +100664,34 @@ pub static WORD_MINIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MINIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIF_CHILDREN),
+static WORD_MINIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ys")],
     values: &[&["minifies"]],
     range: 2..=2,
 };
 
-static WORD_MINIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINIA_CHILDREN),
+static WORD_MINIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["minimal"]],
     range: 1..=1,
 };
 
-static WORD_MING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MING_CHILDREN),
+static WORD_MING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MING_CHILDREN),
     value: None,
 };
 
-pub static WORD_MING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gw"),
         dictgen::InsensitiveStr::Ascii("iame"),
@@ -100700,12 +100700,12 @@ pub static WORD_MING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_MINE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINE_CHILDREN),
+static WORD_MINE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rales"),
         dictgen::InsensitiveStr::Ascii("ras"),
@@ -100715,12 +100715,12 @@ pub static WORD_MINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MIND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIND_CHILDREN),
+static WORD_MIND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIND_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("carck"),
         dictgen::InsensitiveStr::Ascii("crak"),
@@ -100740,12 +100740,12 @@ pub static WORD_MIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_MINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MINA_CHILDREN),
+static WORD_MINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("milist"),
         dictgen::InsensitiveStr::Ascii("ture"),
@@ -100754,12 +100754,12 @@ pub static WORD_MINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_MIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIM_CHILDREN),
+static WORD_MIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("achd"),
@@ -100841,12 +100841,12 @@ pub static WORD_MIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_MIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MIL_CHILDREN),
+static WORD_MIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MIL_CHILDREN),
     value: None,
 };
 
-static WORD_MIL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MIL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MILA_NODE),
     None,
     None,
@@ -100875,23 +100875,23 @@ static WORD_MIL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MILY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILY_CHILDREN),
+static WORD_MILY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ew")],
     values: &[&["milieu"]],
     range: 2..=2,
 };
 
-static WORD_MILW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILW_CHILDREN),
+static WORD_MILW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILW_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("akuee"),
         dictgen::InsensitiveStr::Ascii("uakee"),
@@ -100900,23 +100900,23 @@ pub static WORD_MILW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_MILU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILU_CHILDREN),
+static WORD_MILU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("wakee")],
     values: &[&["milwaukee"]],
     range: 5..=5,
 };
 
-static WORD_MILT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILT_CHILDREN),
+static WORD_MILT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ary"),
         dictgen::InsensitiveStr::Ascii("iant"),
@@ -100936,12 +100936,12 @@ pub static WORD_MILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_MILL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILL_CHILDREN),
+static WORD_MILL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eneum"),
         dictgen::InsensitiveStr::Ascii("enia"),
@@ -101027,12 +101027,12 @@ pub static WORD_MILL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MILK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILK_CHILDREN),
+static WORD_MILK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("toast"),
         dictgen::InsensitiveStr::Ascii("toasts"),
@@ -101041,12 +101041,12 @@ pub static WORD_MILK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_MILI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILI_CHILDREN),
+static WORD_MILI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ary"),
         dictgen::InsensitiveStr::Ascii("cious"),
@@ -101106,12 +101106,12 @@ pub static WORD_MILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MILE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILE_CHILDREN),
+static WORD_MILE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("au"),
         dictgen::InsensitiveStr::Ascii("nnia"),
@@ -101135,12 +101135,12 @@ pub static WORD_MILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_MILA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MILA_CHILDREN),
+static WORD_MILA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MILA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MILA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MILA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("ges"),
@@ -101150,12 +101150,12 @@ pub static WORD_MILA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIK_CHILDREN),
+static WORD_MIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rosecond"),
         dictgen::InsensitiveStr::Ascii("roseconds"),
@@ -101164,12 +101164,12 @@ pub static WORD_MIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=9,
 };
 
-static WORD_MII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MII_CHILDREN),
+static WORD_MII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MII_CHILDREN),
     value: None,
 };
 
-pub static WORD_MII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nimisation"),
         dictgen::InsensitiveStr::Ascii("nimise"),
@@ -101199,23 +101199,23 @@ pub static WORD_MII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=10,
 };
 
-static WORD_MIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIH_CHILDREN),
+static WORD_MIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["might"]],
     range: 1..=1,
 };
 
-static WORD_MIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIG_CHILDREN),
+static WORD_MIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -101253,12 +101253,12 @@ pub static WORD_MIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MID_CHILDREN),
+static WORD_MID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MID_CHILDREN),
     value: None,
 };
 
-pub static WORD_MID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("del"),
         dictgen::InsensitiveStr::Ascii("delware"),
@@ -101330,12 +101330,12 @@ pub static WORD_MID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MIC_CHILDREN),
+static WORD_MIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MIC_CHILDREN),
     value: None,
 };
 
-static WORD_MIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MIC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -101364,12 +101364,12 @@ static WORD_MIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MICR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MICR_CHILDREN),
+static WORD_MICR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MICR_CHILDREN),
     value: None,
 };
 
-static WORD_MICR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MICR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_MICRC_NODE),
@@ -101398,12 +101398,12 @@ static WORD_MICR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MICRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICRS_CHILDREN),
+static WORD_MICRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ft"),
         dictgen::InsensitiveStr::Ascii("oft"),
@@ -101412,12 +101412,12 @@ pub static WORD_MICRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MICRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICRP_CHILDREN),
+static WORD_MICRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hone"),
         dictgen::InsensitiveStr::Ascii("ohone"),
@@ -101426,12 +101426,12 @@ pub static WORD_MICRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_MICRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICRO_CHILDREN),
+static WORD_MICRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cender"),
         dictgen::InsensitiveStr::Ascii("centre"),
@@ -101557,12 +101557,12 @@ pub static WORD_MICRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=13,
 };
 
-static WORD_MICRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICRC_CHILDREN),
+static WORD_MICRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ontroller"),
         dictgen::InsensitiveStr::Ascii("ontrollers"),
@@ -101571,12 +101571,12 @@ pub static WORD_MICRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=10,
 };
 
-static WORD_MICO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICO_CHILDREN),
+static WORD_MICO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rcenter"),
         dictgen::InsensitiveStr::Ascii("rcode"),
@@ -101612,12 +101612,12 @@ pub static WORD_MICO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=13,
 };
 
-static WORD_MICH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICH_CHILDREN),
+static WORD_MICH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agan"),
         dictgen::InsensitiveStr::Ascii("elline"),
@@ -101635,23 +101635,23 @@ pub static WORD_MICH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_MICE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MICE_CHILDREN),
+static WORD_MICE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MICE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MICE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["mice"]],
     range: 1..=1,
 };
 
-static WORD_MIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MIA_CHILDREN),
+static WORD_MIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gic"),
         dictgen::InsensitiveStr::Ascii("gical"),
@@ -101661,23 +101661,23 @@ pub static WORD_MIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_MH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MH_CHILDREN),
+static WORD_MH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ytical")],
     values: &[&["mythical"]],
     range: 6..=6,
 };
 
-static WORD_ME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ME_CHILDREN),
+static WORD_ME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ME_CHILDREN),
     value: None,
 };
 
-static WORD_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MEA_NODE),
     Some(&WORD_MEB_NODE),
     Some(&WORD_MEC_NODE),
@@ -101706,12 +101706,12 @@ static WORD_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MEZ_NODE),
 ];
 
-static WORD_MEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEZ_CHILDREN),
+static WORD_MEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("morise"),
         dictgen::InsensitiveStr::Ascii("morised"),
@@ -101739,23 +101739,23 @@ pub static WORD_MEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=8,
 };
 
-static WORD_MEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEY_CHILDREN),
+static WORD_MEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEY_CHILDREN),
     value: Some(&["may"]),
 };
 
-pub static WORD_MEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("be")],
     values: &[&["maybe"]],
     range: 2..=2,
 };
 
-static WORD_MEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEX_CHILDREN),
+static WORD_MEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cian"),
         dictgen::InsensitiveStr::Ascii("cians"),
@@ -101779,12 +101779,12 @@ pub static WORD_MEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_MET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MET_CHILDREN),
+static WORD_MET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MET_CHILDREN),
     value: None,
 };
 
-static WORD_MET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MET_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_META_NODE),
     None,
     None,
@@ -101813,23 +101813,23 @@ static WORD_MET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_METT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METT_CHILDREN),
+static WORD_METT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METT_CHILDREN),
     value: None,
 };
 
-pub static WORD_METT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["meeting"]],
     range: 3..=3,
 };
 
-static WORD_METR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METR_CHILDREN),
+static WORD_METR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METR_CHILDREN),
     value: None,
 };
 
-pub static WORD_METR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apolis"),
         dictgen::InsensitiveStr::Ascii("i"),
@@ -101897,12 +101897,12 @@ pub static WORD_METR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_METO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METO_CHILDREN),
+static WORD_METO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METO_CHILDREN),
     value: None,
 };
 
-pub static WORD_METO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dologies"),
@@ -101926,23 +101926,23 @@ pub static WORD_METO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_METL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METL_CHILDREN),
+static WORD_METL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METL_CHILDREN),
     value: None,
 };
 
-pub static WORD_METL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("down")],
     values: &[&["meltdown"]],
     range: 4..=4,
 };
 
-static WORD_METI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METI_CHILDREN),
+static WORD_METI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METI_CHILDREN),
     value: None,
 };
 
-pub static WORD_METI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cs"),
         dictgen::InsensitiveStr::Ascii("for"),
@@ -101968,12 +101968,12 @@ pub static WORD_METI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_METH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METH_CHILDREN),
+static WORD_METH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METH_CHILDREN),
     value: None,
 };
 
-pub static WORD_METH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amatician"),
         dictgen::InsensitiveStr::Ascii("aphor"),
@@ -102049,12 +102049,12 @@ pub static WORD_METH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_METE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METE_CHILDREN),
+static WORD_METE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METE_CHILDREN),
     value: None,
 };
 
-pub static WORD_METE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("data"),
         dictgen::InsensitiveStr::Ascii("phorical"),
@@ -102080,23 +102080,23 @@ pub static WORD_METE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_METD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_METD_CHILDREN),
+static WORD_METD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_METD_CHILDREN),
     value: None,
 };
 
-pub static WORD_METD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_METD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ata")],
     values: &[&["metadata"]],
     range: 3..=3,
 };
 
-static WORD_META_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_META_CHILDREN),
+static WORD_META_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_META_CHILDREN),
     value: None,
 };
 
-pub static WORD_META_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_META_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("balism"),
         dictgen::InsensitiveStr::Ascii("bilism"),
@@ -102212,12 +102212,12 @@ pub static WORD_META_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_MES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MES_CHILDREN),
+static WORD_MES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MES_CHILDREN),
     value: None,
 };
 
-pub static WORD_MES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -102339,12 +102339,12 @@ pub static WORD_MES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_MER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MER_CHILDREN),
+static WORD_MER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MER_CHILDREN),
     value: None,
 };
 
-pub static WORD_MER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aj"),
         dictgen::InsensitiveStr::Ascii("ajes"),
@@ -102448,12 +102448,12 @@ pub static WORD_MER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_MEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEO_CHILDREN),
+static WORD_MEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ldic"),
         dictgen::InsensitiveStr::Ascii("ldies"),
@@ -102463,12 +102463,12 @@ pub static WORD_MEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEN_CHILDREN),
+static WORD_MEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("aingful"),
@@ -102566,12 +102566,12 @@ pub static WORD_MEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEM_CHILDREN),
+static WORD_MEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bershup"),
         dictgen::InsensitiveStr::Ascii("bersip"),
@@ -102691,12 +102691,12 @@ pub static WORD_MEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_MEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEL_CHILDREN),
+static WORD_MEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancoly"),
         dictgen::InsensitiveStr::Ascii("anotin"),
@@ -102752,23 +102752,23 @@ pub static WORD_MEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_MEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEK_CHILDREN),
+static WORD_MEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEK_CHILDREN),
     value: Some(&["me"]),
 };
 
-pub static WORD_MEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_MEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEI_CHILDREN),
+static WORD_MEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("da"),
         dictgen::InsensitiveStr::Ascii("dcare"),
@@ -102786,12 +102786,12 @@ pub static WORD_MEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEH_CHILDREN),
+static WORD_MEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("canic"),
         dictgen::InsensitiveStr::Ascii("canical"),
@@ -102823,12 +102823,12 @@ pub static WORD_MEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEG_CHILDREN),
+static WORD_MEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anism"),
         dictgen::InsensitiveStr::Ascii("athred"),
@@ -102839,12 +102839,12 @@ pub static WORD_MEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_MEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEE_CHILDREN),
+static WORD_MEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ans"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -102884,12 +102884,12 @@ pub static WORD_MEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MED_CHILDREN),
+static WORD_MED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MED_CHILDREN),
     value: None,
 };
 
-static WORD_MED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MED_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MEDA_NODE),
     None,
     None,
@@ -102918,12 +102918,12 @@ static WORD_MED_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MEDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDO_CHILDREN),
+static WORD_MEDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icre"),
         dictgen::InsensitiveStr::Ascii("w"),
@@ -102933,12 +102933,12 @@ pub static WORD_MEDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_MEDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDI_CHILDREN),
+static WORD_MEDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("action"),
         dictgen::InsensitiveStr::Ascii("avel"),
@@ -103054,12 +103054,12 @@ pub static WORD_MEDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_MEDH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDH_CHILDREN),
+static WORD_MEDH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("od"),
         dictgen::InsensitiveStr::Ascii("ods"),
@@ -103068,12 +103068,12 @@ pub static WORD_MEDH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MEDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDE_CHILDREN),
+static WORD_MEDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ival"),
         dictgen::InsensitiveStr::Ascii("terranean"),
@@ -103083,12 +103083,12 @@ pub static WORD_MEDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_MEDD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDD_CHILDREN),
+static WORD_MEDD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("os"),
@@ -103097,12 +103097,12 @@ pub static WORD_MEDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_MEDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEDA_CHILDREN),
+static WORD_MEDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEDA_CHILDREN),
     value: Some(&["medal", "media", "meta"]),
 };
 
-pub static WORD_MEDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cine"),
         dictgen::InsensitiveStr::Ascii("i"),
@@ -103113,12 +103113,12 @@ pub static WORD_MEDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_MEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEC_CHILDREN),
+static WORD_MEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahinsm"),
         dictgen::InsensitiveStr::Ascii("ahinsms"),
@@ -103228,12 +103228,12 @@ pub static WORD_MEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_MEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEB_CHILDREN),
+static WORD_MEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -103255,12 +103255,12 @@ pub static WORD_MEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MEA_CHILDREN),
+static WORD_MEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MEA_CHILDREN),
     value: None,
 };
 
-static WORD_MEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MEA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MEAA_NODE),
     None,
     Some(&WORD_MEAC_NODE),
@@ -103289,12 +103289,12 @@ static WORD_MEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MEAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAU_CHILDREN),
+static WORD_MEAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("re"),
         dictgen::InsensitiveStr::Ascii("red"),
@@ -103322,12 +103322,12 @@ pub static WORD_MEAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MEAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAT_CHILDREN),
+static WORD_MEAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adata"),
         dictgen::InsensitiveStr::Ascii("ballers"),
@@ -103347,12 +103347,12 @@ pub static WORD_MEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MEAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAS_CHILDREN),
+static WORD_MEAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("surable"),
         dictgen::InsensitiveStr::Ascii("surably"),
@@ -103408,23 +103408,23 @@ pub static WORD_MEAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MEAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAR_CHILDREN),
+static WORD_MEAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAR_CHILDREN),
     value: Some(&["wear", "mere", "mare"]),
 };
 
-pub static WORD_MEAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["merely", "nearly"]],
     range: 2..=2,
 };
 
-static WORD_MEAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAN_CHILDREN),
+static WORD_MEAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -103466,23 +103466,23 @@ pub static WORD_MEAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MEAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAL_CHILDREN),
+static WORD_MEAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("flur")],
     values: &[&["millefleur"]],
     range: 4..=4,
 };
 
-static WORD_MEAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAI_CHILDREN),
+static WORD_MEAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -103491,12 +103491,12 @@ pub static WORD_MEAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_MEAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAG_CHILDREN),
+static WORD_MEAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thread"),
         dictgen::InsensitiveStr::Ascii("tron"),
@@ -103505,23 +103505,23 @@ pub static WORD_MEAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_MEAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAD_CHILDREN),
+static WORD_MEAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["meaning"]],
     range: 3..=3,
 };
 
-static WORD_MEAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAC_CHILDREN),
+static WORD_MEAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hanism"),
         dictgen::InsensitiveStr::Ascii("hanisms"),
@@ -103541,12 +103541,12 @@ pub static WORD_MEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_MEAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MEAA_CHILDREN),
+static WORD_MEAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MEAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MEAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MEAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sure"),
         dictgen::InsensitiveStr::Ascii("sured"),
@@ -103556,12 +103556,12 @@ pub static WORD_MEAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_MD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MD_CHILDREN),
+static WORD_MD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ification"),
         dictgen::InsensitiveStr::Ascii("ifications"),
@@ -103605,12 +103605,12 @@ pub static WORD_MD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_MC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MC_CHILDREN),
+static WORD_MC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alren"),
         dictgen::InsensitiveStr::Ascii("carhty"),
@@ -103660,12 +103660,12 @@ pub static WORD_MC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_MA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MA_CHILDREN),
+static WORD_MA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MA_CHILDREN),
     value: None,
 };
 
-static WORD_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MAA_NODE),
     Some(&WORD_MAB_NODE),
     Some(&WORD_MAC_NODE),
@@ -103694,23 +103694,23 @@ static WORD_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MAZ_NODE),
 ];
 
-static WORD_MAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAZ_CHILDREN),
+static WORD_MAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("illa")],
     values: &[&["mozilla"]],
     range: 4..=4,
 };
 
-static WORD_MAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAY_CHILDREN),
+static WORD_MAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alsia"),
         dictgen::InsensitiveStr::Ascii("alsian"),
@@ -103756,12 +103756,12 @@ pub static WORD_MAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAX_CHILDREN),
+static WORD_MAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imazing"),
         dictgen::InsensitiveStr::Ascii("imice"),
@@ -103809,34 +103809,34 @@ pub static WORD_MAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_MAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAW_CHILDREN),
+static WORD_MAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("soleum")],
     values: &[&["mausoleum"]],
     range: 6..=6,
 };
 
-static WORD_MAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAV_CHILDREN),
+static WORD_MAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rick")],
     values: &[&["maverick"]],
     range: 4..=4,
 };
 
-static WORD_MAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAU_CHILDREN),
+static WORD_MAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arder"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -103852,12 +103852,12 @@ pub static WORD_MAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_MAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAT_CHILDREN),
+static WORD_MAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAT_CHILDREN),
     value: None,
 };
 
-static WORD_MAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MATA_NODE),
     None,
     Some(&WORD_MATC_NODE),
@@ -103886,23 +103886,23 @@ static WORD_MAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MATZ_NODE),
 ];
 
-static WORD_MATZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATZ_CHILDREN),
+static WORD_MATZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ch")],
     values: &[&["match"]],
     range: 2..=2,
 };
 
-static WORD_MATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATT_CHILDREN),
+static WORD_MATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ern"),
         dictgen::InsensitiveStr::Ascii("erns"),
@@ -103918,23 +103918,23 @@ pub static WORD_MATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATS_CHILDREN),
+static WORD_MATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["master"]],
     range: 2..=2,
 };
 
-static WORD_MATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATR_CHILDREN),
+static WORD_MATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eial"),
         dictgen::InsensitiveStr::Ascii("eials"),
@@ -103962,12 +103962,12 @@ pub static WORD_MATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_MATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATI_CHILDREN),
+static WORD_MATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eral"),
         dictgen::InsensitiveStr::Ascii("eralism"),
@@ -103987,12 +103987,12 @@ pub static WORD_MATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_MATH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATH_CHILDREN),
+static WORD_MATH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amatical"),
         dictgen::InsensitiveStr::Ascii("amatician"),
@@ -104112,12 +104112,12 @@ pub static WORD_MATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_MATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATE_CHILDREN),
+static WORD_MATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("ials"),
@@ -104175,12 +104175,12 @@ pub static WORD_MATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_MATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATC_CHILDREN),
+static WORD_MATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATC_CHILDREN),
     value: Some(&["match"]),
 };
 
-pub static WORD_MATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bh"),
         dictgen::InsensitiveStr::Ascii("hamking"),
@@ -104210,12 +104210,12 @@ pub static WORD_MATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_MATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MATA_CHILDREN),
+static WORD_MATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MATA_CHILDREN),
     value: Some(&["meta", "mater"]),
 };
 
-pub static WORD_MATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ching"),
         dictgen::InsensitiveStr::Ascii("data"),
@@ -104239,12 +104239,12 @@ pub static WORD_MATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_MAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAS_CHILDREN),
+static WORD_MAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAS_CHILDREN),
     value: None,
 };
 
-static WORD_MAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MASA_NODE),
     None,
     Some(&WORD_MASC_NODE),
@@ -104273,23 +104273,23 @@ static WORD_MAS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MASU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASU_CHILDREN),
+static WORD_MASU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("clinity")],
     values: &[&["masculinity"]],
     range: 7..=7,
 };
 
-static WORD_MAST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAST_CHILDREN),
+static WORD_MAST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAST_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eer"),
         dictgen::InsensitiveStr::Ascii("eires"),
@@ -104393,12 +104393,12 @@ pub static WORD_MAST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_MASS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASS_CHILDREN),
+static WORD_MASS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("acer"),
@@ -104458,23 +104458,23 @@ pub static WORD_MASS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_MASR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASR_CHILDREN),
+static WORD_MASR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hmallow")],
     values: &[&["marshmallow"]],
     range: 7..=7,
 };
 
-static WORD_MASQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASQ_CHILDREN),
+static WORD_MASQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uarade"),
         dictgen::InsensitiveStr::Ascii("urade"),
@@ -104483,12 +104483,12 @@ pub static WORD_MASQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_MASO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASO_CHILDREN),
+static WORD_MASO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ginistic"),
         dictgen::InsensitiveStr::Ascii("gynistic"),
@@ -104498,12 +104498,12 @@ pub static WORD_MASO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_MASK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASK_CHILDREN),
+static WORD_MASK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erading"),
         dictgen::InsensitiveStr::Ascii("eraid"),
@@ -104512,12 +104512,12 @@ pub static WORD_MASK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_MASI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASI_CHILDREN),
+static WORD_MASI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("cer"),
@@ -104527,12 +104527,12 @@ pub static WORD_MASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_MASH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASH_CHILDREN),
+static WORD_MASH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("etty"),
@@ -104550,12 +104550,12 @@ pub static WORD_MASH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_MASC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASC_CHILDREN),
+static WORD_MASC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arra"),
         dictgen::InsensitiveStr::Ascii("ulanity"),
@@ -104571,12 +104571,12 @@ pub static WORD_MASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_MASA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MASA_CHILDREN),
+static WORD_MASA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MASA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MASA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cra"),
         dictgen::InsensitiveStr::Ascii("kist"),
@@ -104585,12 +104585,12 @@ pub static WORD_MASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAR_CHILDREN),
+static WORD_MAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAR_CHILDREN),
     value: None,
 };
 
-static WORD_MAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MARA_NODE),
     Some(&WORD_MARB_NODE),
     Some(&WORD_MARC_NODE),
@@ -104619,23 +104619,23 @@ static WORD_MAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_MARZ_NODE),
 ];
 
-static WORD_MARZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARZ_CHILDREN),
+static WORD_MARZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARZ_CHILDREN),
     value: Some(&["march", "mars"]),
 };
 
-pub static WORD_MARZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_MARX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARX_CHILDREN),
+static WORD_MARX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARX_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isim"),
         dictgen::InsensitiveStr::Ascii("isit"),
@@ -104645,34 +104645,34 @@ pub static WORD_MARX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_MARV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARV_CHILDREN),
+static WORD_MARV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("elos")],
     values: &[&["marvelous"]],
     range: 4..=4,
 };
 
-static WORD_MARU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARU_CHILDREN),
+static WORD_MARU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARU_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ader")],
     values: &[&["marauder"]],
     range: 4..=4,
 };
 
-static WORD_MART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MART_CHILDREN),
+static WORD_MART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MART_CHILDREN),
     value: None,
 };
 
-pub static WORD_MART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ail"),
         dictgen::InsensitiveStr::Ascii("ain"),
@@ -104682,12 +104682,12 @@ pub static WORD_MART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARS_CHILDREN),
+static WORD_MARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hamllow"),
         dictgen::InsensitiveStr::Ascii("hamllows"),
@@ -104717,12 +104717,12 @@ pub static WORD_MARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_MARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARR_CHILDREN),
+static WORD_MARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("aige"),
@@ -104740,12 +104740,12 @@ pub static WORD_MARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARN_CHILDREN),
+static WORD_MARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iers"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -104754,23 +104754,23 @@ pub static WORD_MARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARM_CHILDREN),
+static WORD_MARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("elade")],
     values: &[&["marmalade"]],
     range: 5..=5,
 };
 
-static WORD_MARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARL_CHILDREN),
+static WORD_MARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bes"),
         dictgen::InsensitiveStr::Ascii("iyn"),
@@ -104779,12 +104779,12 @@ pub static WORD_MARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_MARK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARK_CHILDREN),
+static WORD_MARK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARK_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aup"),
         dictgen::InsensitiveStr::Ascii("ede"),
@@ -104820,12 +104820,12 @@ pub static WORD_MARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MARJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARJ_CHILDREN),
+static WORD_MARJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iuana"),
         dictgen::InsensitiveStr::Ascii("ority"),
@@ -104834,12 +104834,12 @@ pub static WORD_MARJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_MARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARI_CHILDREN),
+static WORD_MARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abd"),
         dictgen::InsensitiveStr::Ascii("age"),
@@ -104883,12 +104883,12 @@ pub static WORD_MARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MARH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARH_CHILDREN),
+static WORD_MARH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sal"),
         dictgen::InsensitiveStr::Ascii("smallow"),
@@ -104898,12 +104898,12 @@ pub static WORD_MARH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_MARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARG_CHILDREN),
+static WORD_MARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anilize"),
         dictgen::InsensitiveStr::Ascii("anilized"),
@@ -104949,12 +104949,12 @@ pub static WORD_MARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_MARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARE_CHILDREN),
+static WORD_MARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kting"),
         dictgen::InsensitiveStr::Ascii("vlous"),
@@ -104963,23 +104963,23 @@ pub static WORD_MARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_MARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARD_CHILDREN),
+static WORD_MARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("own")],
     values: &[&["markdown"]],
     range: 3..=3,
 };
 
-static WORD_MARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARC_CHILDREN),
+static WORD_MARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hmallows"),
         dictgen::InsensitiveStr::Ascii("ros"),
@@ -104988,12 +104988,12 @@ pub static WORD_MARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_MARB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARB_CHILDREN),
+static WORD_MARB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("els"),
         dictgen::InsensitiveStr::Ascii("leds"),
@@ -105002,12 +105002,12 @@ pub static WORD_MARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_MARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MARA_CHILDREN),
+static WORD_MARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("coni"),
         dictgen::InsensitiveStr::Ascii("deur"),
@@ -105027,12 +105027,12 @@ pub static WORD_MARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_MAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAP_CHILDREN),
+static WORD_MAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -105062,12 +105062,12 @@ pub static WORD_MAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_MAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAN_CHILDREN),
+static WORD_MAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAN_CHILDREN),
     value: None,
 };
 
-static WORD_MAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MANA_NODE),
     None,
     None,
@@ -105096,12 +105096,12 @@ static WORD_MAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MANY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANY_CHILDREN),
+static WORD_MANY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANY_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -105111,12 +105111,12 @@ pub static WORD_MANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_MANU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MANU_CHILDREN),
+static WORD_MANU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MANU_CHILDREN),
     value: None,
 };
 
-static WORD_MANU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MANU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_MANUA_NODE),
     None,
     None,
@@ -105145,23 +105145,23 @@ static WORD_MANU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MANUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUV_CHILDREN),
+static WORD_MANUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["maneuver"]],
     range: 2..=2,
 };
 
-static WORD_MANUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUP_CHILDREN),
+static WORD_MANUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilated"),
         dictgen::InsensitiveStr::Ascii("ilating"),
@@ -105189,12 +105189,12 @@ pub static WORD_MANUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_MANUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUL_CHILDREN),
+static WORD_MANUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -105212,12 +105212,12 @@ pub static WORD_MANUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_MANUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUF_CHILDREN),
+static WORD_MANUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("actered"),
@@ -105329,12 +105329,12 @@ pub static WORD_MANUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_MANUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUE_CHILDREN),
+static WORD_MANUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ll"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -105352,12 +105352,12 @@ pub static WORD_MANUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_MANUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANUA_CHILDREN),
+static WORD_MANUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("les"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -105368,12 +105368,12 @@ pub static WORD_MANUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_MANT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANT_CHILDREN),
+static WORD_MANT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainable"),
@@ -105403,12 +105403,12 @@ pub static WORD_MANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANS_CHILDREN),
+static WORD_MANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alughter"),
         dictgen::InsensitiveStr::Ascii("laugher"),
@@ -105426,12 +105426,12 @@ pub static WORD_MANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_MANO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANO_CHILDREN),
+static WORD_MANO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANO_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euverability"),
         dictgen::InsensitiveStr::Ascii("uevring"),
@@ -105451,12 +105451,12 @@ pub static WORD_MANO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_MANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANN_CHILDREN),
+static WORD_MANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("arisms"),
@@ -105482,12 +105482,12 @@ pub static WORD_MANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_MANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANI_CHILDREN),
+static WORD_MANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("facture"),
         dictgen::InsensitiveStr::Ascii("factured"),
@@ -105619,12 +105619,12 @@ pub static WORD_MANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_MANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANG_CHILDREN),
+static WORD_MANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aed"),
         dictgen::InsensitiveStr::Ascii("aement"),
@@ -105664,12 +105664,12 @@ pub static WORD_MANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_MANF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANF_CHILDREN),
+static WORD_MANF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANF_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acturer"),
         dictgen::InsensitiveStr::Ascii("iest"),
@@ -105687,12 +105687,12 @@ pub static WORD_MANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_MANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANE_CHILDREN),
+static WORD_MANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agable"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -105740,12 +105740,12 @@ pub static WORD_MANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_MAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAND_CHILDREN),
+static WORD_MAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arian"),
         dictgen::InsensitiveStr::Ascii("arijn"),
@@ -105779,12 +105779,12 @@ pub static WORD_MAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MANA_CHILDREN),
+static WORD_MANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("drin"),
         dictgen::InsensitiveStr::Ascii("factured"),
@@ -105858,12 +105858,12 @@ pub static WORD_MANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_MAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAM_CHILDREN),
+static WORD_MAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agement"),
         dictgen::InsensitiveStr::Ascii("al"),
@@ -105885,12 +105885,12 @@ pub static WORD_MAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_MAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAL_CHILDREN),
+static WORD_MAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aira"),
         dictgen::InsensitiveStr::Ascii("ariya"),
@@ -105980,12 +105980,12 @@ pub static WORD_MAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_MAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAK_CHILDREN),
+static WORD_MAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAK_CHILDREN),
     value: Some(&["make", "mask"]),
 };
 
-pub static WORD_MAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -106023,23 +106023,23 @@ pub static WORD_MAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_MAJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAJ_CHILDREN),
+static WORD_MAJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oroty")],
     values: &[&["majority"]],
     range: 5..=5,
 };
 
-static WORD_MAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_MAI_CHILDREN),
+static WORD_MAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_MAI_CHILDREN),
     value: None,
 };
 
-static WORD_MAI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_MAI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_MAIB_NODE),
     None,
@@ -106068,12 +106068,12 @@ static WORD_MAI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_MAIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIT_CHILDREN),
+static WORD_MAIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainance"),
@@ -106091,12 +106091,12 @@ pub static WORD_MAIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_MAIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIR_CHILDREN),
+static WORD_MAIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abd"),
         dictgen::InsensitiveStr::Ascii("adb"),
@@ -106107,12 +106107,12 @@ pub static WORD_MAIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_MAIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIN_CHILDREN),
+static WORD_MAIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ained"),
         dictgen::InsensitiveStr::Ascii("ainer"),
@@ -106224,23 +106224,23 @@ pub static WORD_MAIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_MAIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIM_CHILDREN),
+static WORD_MAIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("um")],
     values: &[&["maximum"]],
     range: 2..=2,
 };
 
-static WORD_MAIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIL_CHILDREN),
+static WORD_MAIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("formed"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -106251,23 +106251,23 @@ pub static WORD_MAIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_MAID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAID_CHILDREN),
+static WORD_MAID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAID_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("son")],
     values: &[&["madison"]],
     range: 3..=3,
 };
 
-static WORD_MAIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAIB_CHILDREN),
+static WORD_MAIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ox"),
@@ -106276,23 +106276,23 @@ pub static WORD_MAIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_MAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAH_CHILDREN),
+static WORD_MAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cine")],
     values: &[&["machine"]],
     range: 4..=4,
 };
 
-static WORD_MAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAG_CHILDREN),
+static WORD_MAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainzes"),
         dictgen::InsensitiveStr::Ascii("asine"),
@@ -106368,12 +106368,12 @@ pub static WORD_MAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_MAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAE_CHILDREN),
+static WORD_MAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aningless"),
         dictgen::InsensitiveStr::Ascii("stries"),
@@ -106397,12 +106397,12 @@ pub static WORD_MAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_MAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAD_CHILDREN),
+static WORD_MAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antory"),
         dictgen::InsensitiveStr::Ascii("atory"),
@@ -106422,12 +106422,12 @@ pub static WORD_MAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_MAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAC_CHILDREN),
+static WORD_MAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("arino"),
@@ -106509,12 +106509,12 @@ pub static WORD_MAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_MAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAB_CHILDREN),
+static WORD_MAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ye"),
@@ -106524,12 +106524,12 @@ pub static WORD_MAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_MAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_MAA_CHILDREN),
+static WORD_MAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_MAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_MAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_MAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ke"),
         dictgen::InsensitiveStr::Ascii("nagement"),
@@ -106547,12 +106547,12 @@ pub static WORD_MAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_L_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_L_CHILDREN),
+static WORD_L_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_L_CHILDREN),
     value: None,
 };
 
-static WORD_L_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_L_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LA_NODE),
     None,
     Some(&WORD_LC_NODE),
@@ -106581,12 +106581,12 @@ static WORD_L_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LY_CHILDREN),
+static WORD_LY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bia"),
         dictgen::InsensitiveStr::Ascii("che"),
@@ -106595,12 +106595,12 @@ pub static WORD_LY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=3,
 };
 
-static WORD_LV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LV_CHILDREN),
+static WORD_LV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LV_CHILDREN),
     value: None,
 };
 
-pub static WORD_LV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eo"),
         dictgen::InsensitiveStr::Ascii("oe"),
@@ -106609,12 +106609,12 @@ pub static WORD_LV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_LU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LU_CHILDREN),
+static WORD_LU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anched"),
         dictgen::InsensitiveStr::Ascii("ancher"),
@@ -106688,23 +106688,23 @@ pub static WORD_LU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_LT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LT_CHILDREN),
+static WORD_LT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eral")],
     values: &[&["literal"]],
     range: 4..=4,
 };
 
-static WORD_LS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LS_CHILDREN),
+static WORD_LS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LS_CHILDREN),
     value: None,
 };
 
-pub static WORD_LS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ip"),
@@ -106724,23 +106724,23 @@ pub static WORD_LS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_LP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LP_CHILDREN),
+static WORD_LP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LP_CHILDREN),
     value: None,
 };
 
-pub static WORD_LP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atform")],
     values: &[&["platform"]],
     range: 6..=6,
 };
 
-static WORD_LO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LO_CHILDREN),
+static WORD_LO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LO_CHILDREN),
     value: None,
 };
 
-static WORD_LO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LOA_NODE),
     Some(&WORD_LOB_NODE),
     Some(&WORD_LOC_NODE),
@@ -106769,34 +106769,34 @@ static WORD_LO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_LOZ_NODE),
 ];
 
-static WORD_LOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOZ_CHILDREN),
+static WORD_LOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onya")],
     values: &[&["lasagna"]],
     range: 4..=4,
 };
 
-static WORD_LOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOY_CHILDREN),
+static WORD_LOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ality")],
     values: &[&["loyalty"]],
     range: 5..=5,
 };
 
-static WORD_LOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOW_CHILDREN),
+static WORD_LOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("case"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -106806,23 +106806,23 @@ pub static WORD_LOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_LOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOV_CHILDREN),
+static WORD_LOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOV_CHILDREN),
     value: Some(&["love"]),
 };
 
-pub static WORD_LOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ley")],
     values: &[&["lovely"]],
     range: 3..=3,
 };
 
-static WORD_LOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOU_CHILDREN),
+static WORD_LOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ieville"),
         dictgen::InsensitiveStr::Ascii("isiania"),
@@ -106846,12 +106846,12 @@ pub static WORD_LOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=8,
 };
 
-static WORD_LOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOT_CHILDREN),
+static WORD_LOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("haringen"),
@@ -106860,12 +106860,12 @@ pub static WORD_LOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_LOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOS_CHILDREN),
+static WORD_LOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -106887,23 +106887,23 @@ pub static WORD_LOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOR_CHILDREN),
+static WORD_LOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eplay")],
     values: &[&["roleplay"]],
     range: 5..=5,
 };
 
-static WORD_LOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOO_CHILDREN),
+static WORD_LOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("back"),
         dictgen::InsensitiveStr::Ascii("backs"),
@@ -106957,12 +106957,12 @@ pub static WORD_LOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LON_CHILDREN),
+static WORD_LON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LON_CHILDREN),
     value: None,
 };
 
-pub static WORD_LON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -107018,12 +107018,12 @@ pub static WORD_LON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_LOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOL_CHILDREN),
+static WORD_LOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("erant"),
@@ -107034,12 +107034,12 @@ pub static WORD_LOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOK_CHILDREN),
+static WORD_LOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOK_CHILDREN),
     value: Some(&["look"]),
 };
 
-pub static WORD_LOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ale"),
@@ -107057,12 +107057,12 @@ pub static WORD_LOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_LOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOI_CHILDREN),
+static WORD_LOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("gns"),
@@ -107073,12 +107073,12 @@ pub static WORD_LOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOG_CHILDREN),
+static WORD_LOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arighmic"),
         dictgen::InsensitiveStr::Ascii("arithimic"),
@@ -107154,12 +107154,12 @@ pub static WORD_LOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_LOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOE_CHILDREN),
+static WORD_LOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nard"),
         dictgen::InsensitiveStr::Ascii("pard"),
@@ -107169,12 +107169,12 @@ pub static WORD_LOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_LOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOD_CHILDREN),
+static WORD_LOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOD_CHILDREN),
     value: Some(&["load"]),
 };
 
-pub static WORD_LOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("aer"),
@@ -107194,12 +107194,12 @@ pub static WORD_LOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_LOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOC_CHILDREN),
+static WORD_LOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ae"),
@@ -107295,12 +107295,12 @@ pub static WORD_LOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_LOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOB_CHILDREN),
+static WORD_LOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("byistes"),
         dictgen::InsensitiveStr::Ascii("bysits"),
@@ -107309,12 +107309,12 @@ pub static WORD_LOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_LOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LOA_CHILDREN),
+static WORD_LOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ader"),
         dictgen::InsensitiveStr::Ascii("cal"),
@@ -107346,12 +107346,12 @@ pub static WORD_LOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_LN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LN_CHILDREN),
+static WORD_LN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("guage"),
         dictgen::InsensitiveStr::Ascii("guages"),
@@ -107362,12 +107362,12 @@ pub static WORD_LN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_LM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LM_CHILDREN),
+static WORD_LM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LM_CHILDREN),
     value: None,
 };
 
-pub static WORD_LM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ited"),
         dictgen::InsensitiveStr::Ascii("its"),
@@ -107376,12 +107376,12 @@ pub static WORD_LM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_LL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LL_CHILDREN),
+static WORD_LL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LL_CHILDREN),
     value: None,
 };
 
-pub static WORD_LL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ike"),
         dictgen::InsensitiveStr::Ascii("inear"),
@@ -107392,23 +107392,23 @@ pub static WORD_LL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_LK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LK_CHILDREN),
+static WORD_LK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LK_CHILDREN),
     value: None,
 };
 
-pub static WORD_LK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["like"]],
     range: 1..=1,
 };
 
-static WORD_LI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LI_CHILDREN),
+static WORD_LI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LI_CHILDREN),
     value: None,
 };
 
-static WORD_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LIA_NODE),
     Some(&WORD_LIB_NODE),
     Some(&WORD_LIC_NODE),
@@ -107437,12 +107437,12 @@ static WORD_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_LIZ_NODE),
 ];
 
-static WORD_LIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIZ_CHILDREN),
+static WORD_LIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ens"),
         dictgen::InsensitiveStr::Ascii("ense"),
@@ -107452,12 +107452,12 @@ pub static WORD_LIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_LIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIV_CHILDREN),
+static WORD_LIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eatream"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -107495,12 +107495,12 @@ pub static WORD_LIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIU_CHILDREN),
+static WORD_LIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etenant"),
         dictgen::InsensitiveStr::Ascii("ke"),
@@ -107509,12 +107509,12 @@ pub static WORD_LIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIT_CHILDREN),
+static WORD_LIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aral"),
         dictgen::InsensitiveStr::Ascii("arally"),
@@ -107642,12 +107642,12 @@ pub static WORD_LIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_LIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIS_CHILDREN),
+static WORD_LIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cence"),
         dictgen::InsensitiveStr::Ascii("cense"),
@@ -107717,12 +107717,12 @@ pub static WORD_LIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_LIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIQ_CHILDREN),
+static WORD_LIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iuds"),
         dictgen::InsensitiveStr::Ascii("uidas"),
@@ -107740,12 +107740,12 @@ pub static WORD_LIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_LIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIP_CHILDREN),
+static WORD_LIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pizaner"),
         dictgen::InsensitiveStr::Ascii("stics"),
@@ -107754,23 +107754,23 @@ pub static WORD_LIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_LIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIO_CHILDREN),
+static WORD_LIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("usville")],
     values: &[&["louisville"]],
     range: 7..=7,
 };
 
-static WORD_LIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIN_CHILDREN),
+static WORD_LIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("ar"),
@@ -107870,12 +107870,12 @@ pub static WORD_LIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_LIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIM_CHILDREN),
+static WORD_LIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iation"),
         dictgen::InsensitiveStr::Ascii("iations"),
@@ -107971,23 +107971,23 @@ pub static WORD_LIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_LIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIL_CHILDREN),
+static WORD_LIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eral")],
     values: &[&["literal"]],
     range: 4..=4,
 };
 
-static WORD_LIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIK_CHILDREN),
+static WORD_LIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIK_CHILDREN),
     value: Some(&["like", "lick", "link"]),
 };
 
-pub static WORD_LIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebale"),
         dictgen::InsensitiveStr::Ascii("eley"),
@@ -108017,23 +108017,23 @@ pub static WORD_LIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_LII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LII_CHILDREN),
+static WORD_LII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LII_CHILDREN),
     value: None,
 };
 
-pub static WORD_LII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tle")],
     values: &[&["little"]],
     range: 3..=3,
 };
 
-static WORD_LIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIG_CHILDREN),
+static WORD_LIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hbar"),
@@ -108149,12 +108149,12 @@ pub static WORD_LIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_LIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIF_CHILDREN),
+static WORD_LIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceycle"),
         dictgen::InsensitiveStr::Ascii("ecicle"),
@@ -108200,12 +108200,12 @@ pub static WORD_LIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIE_CHILDREN),
+static WORD_LIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("brals"),
         dictgen::InsensitiveStr::Ascii("cester"),
@@ -108259,12 +108259,12 @@ pub static WORD_LIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_LIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIC_CHILDREN),
+static WORD_LIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -108322,12 +108322,12 @@ pub static WORD_LIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_LIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LIB_CHILDREN),
+static WORD_LIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LIB_CHILDREN),
     value: None,
 };
 
-static WORD_LIB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LIB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LIBA_NODE),
     None,
     None,
@@ -108356,12 +108356,12 @@ static WORD_LIB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LIBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBR_CHILDREN),
+static WORD_LIBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBR_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aarie"),
         dictgen::InsensitiveStr::Ascii("aaries"),
@@ -108463,34 +108463,34 @@ pub static WORD_LIBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_LIBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBL_CHILDREN),
+static WORD_LIBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["libel", "liable"]],
     range: 1..=1,
 };
 
-static WORD_LIBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBI_CHILDREN),
+static WORD_LIBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tarianisn")],
     values: &[&["libertarianism"]],
     range: 9..=9,
 };
 
-static WORD_LIBG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBG_CHILDREN),
+static WORD_LIBG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("uistic"),
@@ -108500,12 +108500,12 @@ pub static WORD_LIBG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_LIBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBE_CHILDREN),
+static WORD_LIBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ll"),
         dictgen::InsensitiveStr::Ascii("racion"),
@@ -108617,12 +108617,12 @@ pub static WORD_LIBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_LIBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIBA_CHILDREN),
+static WORD_LIBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rary"),
         dictgen::InsensitiveStr::Ascii("ries"),
@@ -108632,12 +108632,12 @@ pub static WORD_LIBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_LIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LIA_CHILDREN),
+static WORD_LIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blity"),
         dictgen::InsensitiveStr::Ascii("res"),
@@ -108659,34 +108659,34 @@ pub static WORD_LIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_LG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LG_CHILDREN),
+static WORD_LG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eacy")],
     values: &[&["legacy"]],
     range: 4..=4,
 };
 
-static WORD_LF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LF_CHILDREN),
+static WORD_LF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LF_CHILDREN),
     value: None,
 };
 
-pub static WORD_LF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iesteal")],
     values: &[&["lifesteal"]],
     range: 7..=7,
 };
 
-static WORD_LE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LE_CHILDREN),
+static WORD_LE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LE_CHILDREN),
     value: None,
 };
 
-static WORD_LE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LEA_NODE),
     Some(&WORD_LEB_NODE),
     Some(&WORD_LEC_NODE),
@@ -108715,12 +108715,12 @@ static WORD_LE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEY_CHILDREN),
+static WORD_LEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -108731,12 +108731,12 @@ pub static WORD_LEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_LEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEX_CHILDREN),
+static WORD_LEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("icographycally"),
@@ -108760,12 +108760,12 @@ pub static WORD_LEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=14,
 };
 
-static WORD_LEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEW_CHILDREN),
+static WORD_LEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEW_CHILDREN),
     value: Some(&["dew", "hew", "lieu", "sew"]),
 };
 
-pub static WORD_LEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chemia"),
         dictgen::InsensitiveStr::Ascii("ow"),
@@ -108783,12 +108783,12 @@ pub static WORD_LEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEV_CHILDREN),
+static WORD_LEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aithan"),
@@ -108834,12 +108834,12 @@ pub static WORD_LEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_LEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEU_CHILDREN),
+static WORD_LEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itenant"),
         dictgen::InsensitiveStr::Ascii("tenant"),
@@ -108848,12 +108848,12 @@ pub static WORD_LEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_LET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LET_CHILDREN),
+static WORD_LET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LET_CHILDREN),
     value: None,
 };
 
-pub static WORD_LET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gitimate"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -108864,12 +108864,12 @@ pub static WORD_LET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_LES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LES_CHILDREN),
+static WORD_LES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LES_CHILDREN),
     value: None,
 };
 
-pub static WORD_LES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bain"),
         dictgen::InsensitiveStr::Ascii("bains"),
@@ -108901,12 +108901,12 @@ pub static WORD_LES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_LER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LER_CHILDREN),
+static WORD_LER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LER_CHILDREN),
     value: None,
 };
 
-pub static WORD_LER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("aned"),
@@ -108926,12 +108926,12 @@ pub static WORD_LER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_LEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEP_CHILDREN),
+static WORD_LEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -108955,12 +108955,12 @@ pub static WORD_LEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_LEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEN_CHILDREN),
+static WORD_LEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("gedaries"),
@@ -109040,12 +109040,12 @@ pub static WORD_LEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_LEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEM_CHILDREN),
+static WORD_LEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("osine"),
         dictgen::InsensitiveStr::Ascii("osines"),
@@ -109054,12 +109054,12 @@ pub static WORD_LEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_LEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEI_CHILDREN),
+static WORD_LEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bnitz"),
         dictgen::InsensitiveStr::Ascii("ghtweight"),
@@ -109075,12 +109075,12 @@ pub static WORD_LEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_LEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LEG_CHILDREN),
+static WORD_LEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LEG_CHILDREN),
     value: None,
 };
 
-static WORD_LEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LEG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LEGA_NODE),
     None,
     None,
@@ -109109,12 +109109,12 @@ static WORD_LEG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LEGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGT_CHILDREN),
+static WORD_LEGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGT_CHILDREN),
     value: Some(&["left", "legit"]),
 };
 
-pub static WORD_LEGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hs"),
@@ -109123,23 +109123,23 @@ pub static WORD_LEGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_LEGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGO_CHILDREN),
+static WORD_LEGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGO_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ins")],
     values: &[&["legions"]],
     range: 3..=3,
 };
 
-static WORD_LEGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGN_CHILDREN),
+static WORD_LEGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edaries"),
         dictgen::InsensitiveStr::Ascii("edary"),
@@ -109157,12 +109157,12 @@ pub static WORD_LEGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_LEGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGI_CHILDREN),
+static WORD_LEGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lsation"),
         dictgen::InsensitiveStr::Ascii("mitacy"),
@@ -109250,12 +109250,12 @@ pub static WORD_LEGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_LEGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGH_CHILDREN),
+static WORD_LEGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGH_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -109264,12 +109264,12 @@ pub static WORD_LEGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_LEGG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGG_CHILDREN),
+static WORD_LEGG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acies"),
         dictgen::InsensitiveStr::Ascii("acy"),
@@ -109278,12 +109278,12 @@ pub static WORD_LEGG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_LEGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGE_CHILDREN),
+static WORD_LEGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("nadries"),
@@ -109315,12 +109315,12 @@ pub static WORD_LEGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_LEGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEGA_CHILDREN),
+static WORD_LEGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -109352,12 +109352,12 @@ pub static WORD_LEGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_LEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEF_CHILDREN),
+static WORD_LEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itst"),
         dictgen::InsensitiveStr::Ascii("itsts"),
@@ -109375,12 +109375,12 @@ pub static WORD_LEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_LEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEE_CHILDREN),
+static WORD_LEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gs"),
@@ -109402,12 +109402,12 @@ pub static WORD_LEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEC_CHILDREN),
+static WORD_LEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eister"),
         dictgen::InsensitiveStr::Ascii("iester"),
@@ -109425,23 +109425,23 @@ pub static WORD_LEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_LEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEB_CHILDREN),
+static WORD_LEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("anesse")],
     values: &[&["lebanese"]],
     range: 6..=6,
 };
 
-static WORD_LEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LEA_CHILDREN),
+static WORD_LEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -109533,12 +109533,12 @@ pub static WORD_LEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_LC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LC_CHILDREN),
+static WORD_LC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oal"),
         dictgen::InsensitiveStr::Ascii("oally"),
@@ -109556,12 +109556,12 @@ pub static WORD_LC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_LA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LA_CHILDREN),
+static WORD_LA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LA_CHILDREN),
     value: None,
 };
 
-static WORD_LA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_LAB_NODE),
     Some(&WORD_LAC_NODE),
@@ -109590,12 +109590,12 @@ static WORD_LA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_LAZ_NODE),
 ];
 
-static WORD_LAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAZ_CHILDREN),
+static WORD_LAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("iliy"),
@@ -109605,12 +109605,12 @@ pub static WORD_LAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_LAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAY_CHILDREN),
+static WORD_LAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("brinth"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -109644,23 +109644,23 @@ pub static WORD_LAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_LAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAW_CHILDREN),
+static WORD_LAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ernce")],
     values: &[&["lawrence"]],
     range: 5..=5,
 };
 
-static WORD_LAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAV_CHILDREN),
+static WORD_LAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -109686,12 +109686,12 @@ pub static WORD_LAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_LAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAU_CHILDREN),
+static WORD_LAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -109751,12 +109751,12 @@ pub static WORD_LAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_LAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAT_CHILDREN),
+static WORD_LAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecny"),
         dictgen::InsensitiveStr::Ascii("enciy"),
@@ -109804,12 +109804,12 @@ pub static WORD_LAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_LAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAS_CHILDREN),
+static WORD_LAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agnea"),
         dictgen::InsensitiveStr::Ascii("agnia"),
@@ -109835,12 +109835,12 @@ pub static WORD_LAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_LAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAR_CHILDREN),
+static WORD_LAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eady"),
         dictgen::InsensitiveStr::Ascii("egly"),
@@ -109884,12 +109884,12 @@ pub static WORD_LAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAO_CHILDREN),
+static WORD_LAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -109913,12 +109913,12 @@ pub static WORD_LAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_LAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LAN_CHILDREN),
+static WORD_LAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LAN_CHILDREN),
     value: None,
 };
 
-static WORD_LAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LANA_NODE),
     None,
     None,
@@ -109947,12 +109947,12 @@ static WORD_LAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LANU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANU_CHILDREN),
+static WORD_LANU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -109978,23 +109978,23 @@ pub static WORD_LANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_LANT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANT_CHILDREN),
+static WORD_LANT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ren")],
     values: &[&["lantern"]],
     range: 3..=3,
 };
 
-static WORD_LANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANN_CHILDREN),
+static WORD_LANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asters"),
         dictgen::InsensitiveStr::Ascii("esters"),
@@ -110014,23 +110014,23 @@ pub static WORD_LANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_LANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANI_CHILDREN),
+static WORD_LANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ch")],
     values: &[&["launch"]],
     range: 2..=2,
 };
 
-static WORD_LANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_LANG_CHILDREN),
+static WORD_LANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_LANG_CHILDREN),
     value: None,
 };
 
-static WORD_LANG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_LANG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_LANGA_NODE),
     None,
     None,
@@ -110059,12 +110059,12 @@ static WORD_LANG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_LANGY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGY_CHILDREN),
+static WORD_LANGY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGY_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -110073,12 +110073,12 @@ pub static WORD_LANGY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_LANGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGU_CHILDREN),
+static WORD_LANGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGU_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -110182,12 +110182,12 @@ pub static WORD_LANGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_LANGT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGT_CHILDREN),
+static WORD_LANGT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGT_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hs"),
@@ -110196,12 +110196,12 @@ pub static WORD_LANGT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_LANGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGN_CHILDREN),
+static WORD_LANGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("guage"),
         dictgen::InsensitiveStr::Ascii("guages"),
@@ -110210,12 +110210,12 @@ pub static WORD_LANGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_LANGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGI_CHILDREN),
+static WORD_LANGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -110224,12 +110224,12 @@ pub static WORD_LANGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_LANGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGH_CHILDREN),
+static WORD_LANGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGH_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -110238,12 +110238,12 @@ pub static WORD_LANGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_LANGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGE_CHILDREN),
+static WORD_LANGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rie"),
         dictgen::InsensitiveStr::Ascii("rray"),
@@ -110259,12 +110259,12 @@ pub static WORD_LANGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_LANGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANGA_CHILDREN),
+static WORD_LANGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("ges"),
@@ -110286,12 +110286,12 @@ pub static WORD_LANGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_LAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAND_CHILDREN),
+static WORD_LAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acapes"),
         dictgen::InsensitiveStr::Ascii("ingers"),
@@ -110319,12 +110319,12 @@ pub static WORD_LAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_LANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LANA_CHILDREN),
+static WORD_LANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_LANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("guage"),
         dictgen::InsensitiveStr::Ascii("guge"),
@@ -110346,12 +110346,12 @@ pub static WORD_LANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_LAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAM_CHILDREN),
+static WORD_LAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("da"),
         dictgen::InsensitiveStr::Ascii("das"),
@@ -110361,23 +110361,23 @@ pub static WORD_LAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_LAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAI_CHILDREN),
+static WORD_LAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["later"]],
     range: 3..=3,
 };
 
-static WORD_LAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAG_CHILDREN),
+static WORD_LAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acies"),
         dictgen::InsensitiveStr::Ascii("acy"),
@@ -110403,34 +110403,34 @@ pub static WORD_LAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_LAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAF_CHILDREN),
+static WORD_LAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAF_CHILDREN),
     value: Some(&["kaf", "kaph", "lac", "lad", "lag", "laugh", "leaf", "loaf"]),
 };
 
-pub static WORD_LAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_LAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAE_CHILDREN),
+static WORD_LAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["later", "layer"]],
     range: 1..=1,
 };
 
-static WORD_LAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAC_CHILDREN),
+static WORD_LAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kbuster"),
         dictgen::InsensitiveStr::Ascii("ker"),
@@ -110460,12 +110460,12 @@ pub static WORD_LAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_LAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_LAB_CHILDREN),
+static WORD_LAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_LAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_LAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_LAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alled"),
         dictgen::InsensitiveStr::Ascii("arotory"),
@@ -110539,12 +110539,12 @@ pub static WORD_LAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_K_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_K_CHILDREN),
+static WORD_K_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_K_CHILDREN),
     value: None,
 };
 
-static WORD_K_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_K_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_KA_NODE),
     None,
     None,
@@ -110573,12 +110573,12 @@ static WORD_K_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_KY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KY_CHILDREN),
+static WORD_KY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KY_CHILDREN),
     value: None,
 };
 
-pub static WORD_KY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebosh"),
         dictgen::InsensitiveStr::Ascii("eboshed"),
@@ -110598,12 +110598,12 @@ pub static WORD_KY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_KW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KW_CHILDREN),
+static WORD_KW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KW_CHILDREN),
     value: None,
 };
 
-pub static WORD_KW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eyword"),
         dictgen::InsensitiveStr::Ascii("no"),
@@ -110621,12 +110621,12 @@ pub static WORD_KW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_KU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KU_CHILDREN),
+static WORD_KU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KU_CHILDREN),
     value: None,
 };
 
-pub static WORD_KU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("benates"),
         dictgen::InsensitiveStr::Ascii("benernetes"),
@@ -110676,23 +110676,23 @@ pub static WORD_KU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=10,
 };
 
-static WORD_KT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KT_CHILDREN),
+static WORD_KT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KT_CHILDREN),
     value: None,
 };
 
-pub static WORD_KT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ichen")],
     values: &[&["kitchen"]],
     range: 5..=5,
 };
 
-static WORD_KR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KR_CHILDREN),
+static WORD_KR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KR_CHILDREN),
     value: None,
 };
 
-pub static WORD_KR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ankenstein"),
         dictgen::InsensitiveStr::Ascii("esh"),
@@ -110740,12 +110740,12 @@ pub static WORD_KR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_KO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KO_CHILDREN),
+static WORD_KO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KO_CHILDREN),
     value: None,
 };
 
-pub static WORD_KO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("calized"),
         dictgen::InsensitiveStr::Ascii("llaboration"),
@@ -110829,12 +110829,12 @@ pub static WORD_KO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_KN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KN_CHILDREN),
+static WORD_KN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KN_CHILDREN),
     value: None,
 };
 
-pub static WORD_KN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arl"),
         dictgen::InsensitiveStr::Ascii("arled"),
@@ -110958,23 +110958,23 @@ pub static WORD_KN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_KM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KM_CHILDREN),
+static WORD_KM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KM_CHILDREN),
     value: None,
 };
 
-pub static WORD_KM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ow")],
     values: &[&["know"]],
     range: 2..=2,
 };
 
-static WORD_KL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KL_CHILDREN),
+static WORD_KL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KL_CHILDREN),
     value: None,
 };
 
-pub static WORD_KL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enex"),
         dictgen::InsensitiveStr::Ascii("ick"),
@@ -110992,23 +110992,23 @@ pub static WORD_KL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_KK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KK_CHILDREN),
+static WORD_KK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KK_CHILDREN),
     value: None,
 };
 
-pub static WORD_KK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("now")],
     values: &[&["know"]],
     range: 3..=3,
 };
 
-static WORD_KI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_KI_CHILDREN),
+static WORD_KI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_KI_CHILDREN),
     value: None,
 };
 
-static WORD_KI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_KI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_KIB_NODE),
     Some(&WORD_KIC_NODE),
@@ -111037,12 +111037,12 @@ static WORD_KI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_KIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIY_CHILDREN),
+static WORD_KIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("acked"),
@@ -111062,12 +111062,12 @@ pub static WORD_KIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_KIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIT_CHILDREN),
+static WORD_KIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ches"),
         dictgen::InsensitiveStr::Ascii("ites"),
@@ -111077,12 +111077,12 @@ pub static WORD_KIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_KIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIN_CHILDREN),
+static WORD_KIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dapped"),
         dictgen::InsensitiveStr::Ascii("dapping"),
@@ -111124,12 +111124,12 @@ pub static WORD_KIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_KIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIM_CHILDREN),
+static WORD_KIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("era"),
         dictgen::InsensitiveStr::Ascii("eric"),
@@ -111153,12 +111153,12 @@ pub static WORD_KIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_KIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIL_CHILDREN),
+static WORD_KIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lingest"),
         dictgen::InsensitiveStr::Ascii("lins"),
@@ -111182,12 +111182,12 @@ pub static WORD_KIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_KIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIG_CHILDREN),
+static WORD_KIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hbosh"),
         dictgen::InsensitiveStr::Ascii("hboshed"),
@@ -111198,12 +111198,12 @@ pub static WORD_KIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_KID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KID_CHILDREN),
+static WORD_KID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KID_CHILDREN),
     value: None,
 };
 
-pub static WORD_KID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("knap"),
         dictgen::InsensitiveStr::Ascii("knapped"),
@@ -111239,12 +111239,12 @@ pub static WORD_KID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_KIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIC_CHILDREN),
+static WORD_KIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kstarer"),
         dictgen::InsensitiveStr::Ascii("kstartr"),
@@ -111262,12 +111262,12 @@ pub static WORD_KIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_KIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KIB_CHILDREN),
+static WORD_KIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_KIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("utz"),
         dictgen::InsensitiveStr::Ascii("utzes"),
@@ -111277,12 +111277,12 @@ pub static WORD_KIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_KE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_KE_CHILDREN),
+static WORD_KE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_KE_CHILDREN),
     value: None,
 };
 
-static WORD_KE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_KE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_KEB_NODE),
     None,
@@ -111311,12 +111311,12 @@ static WORD_KE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_KEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEY_CHILDREN),
+static WORD_KEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baord"),
         dictgen::InsensitiveStr::Ascii("baords"),
@@ -111404,12 +111404,12 @@ pub static WORD_KEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_KEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEW_CHILDREN),
+static WORD_KEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ord"),
         dictgen::InsensitiveStr::Ascii("ords"),
@@ -111420,23 +111420,23 @@ pub static WORD_KEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_KET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KET_CHILDREN),
+static WORD_KET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KET_CHILDREN),
     value: Some(&["kept", "key"]),
 };
 
-pub static WORD_KET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("maine")],
     values: &[&["ketamine"]],
     range: 5..=5,
 };
 
-static WORD_KER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KER_CHILDREN),
+static WORD_KER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KER_CHILDREN),
     value: None,
 };
 
-pub static WORD_KER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enl"),
         dictgen::InsensitiveStr::Ascii("enls"),
@@ -111460,12 +111460,12 @@ pub static WORD_KER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_KEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEP_CHILDREN),
+static WORD_KEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oint"),
         dictgen::InsensitiveStr::Ascii("oints"),
@@ -111483,12 +111483,12 @@ pub static WORD_KEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_KEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEN_CHILDREN),
+static WORD_KEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("els"),
@@ -111522,12 +111522,12 @@ pub static WORD_KEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_KEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEE_CHILDREN),
+static WORD_KEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alive"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -111547,23 +111547,23 @@ pub static WORD_KEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_KEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KEB_CHILDREN),
+static WORD_KEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_KEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oard")],
     values: &[&["keyboard"]],
     range: 4..=4,
 };
 
-static WORD_KA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_KA_CHILDREN),
+static WORD_KA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_KA_CHILDREN),
     value: None,
 };
 
-pub static WORD_KA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_KA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckie"),
         dictgen::InsensitiveStr::Ascii("ckies"),
@@ -111603,12 +111603,12 @@ pub static WORD_KA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_J_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_J_CHILDREN),
+static WORD_J_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_J_CHILDREN),
     value: None,
 };
 
-static WORD_J_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_J_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_JA_NODE),
     None,
     None,
@@ -111637,12 +111637,12 @@ static WORD_J_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_JU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_JU_CHILDREN),
+static WORD_JU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_JU_CHILDREN),
     value: None,
 };
 
-static WORD_JU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_JU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_JUA_NODE),
     None,
     None,
@@ -111671,12 +111671,12 @@ static WORD_JU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_JUX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUX_CHILDREN),
+static WORD_JUX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUX_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tification"),
@@ -111698,12 +111698,12 @@ pub static WORD_JUX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_JUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUV_CHILDREN),
+static WORD_JUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eline"),
         dictgen::InsensitiveStr::Ascii("enille"),
@@ -111714,12 +111714,12 @@ pub static WORD_JUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_JUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUS_CHILDREN),
+static WORD_JUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUS_CHILDREN),
     value: Some(&["just"]),
 };
 
-pub static WORD_JUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("itfication"),
@@ -111771,12 +111771,12 @@ pub static WORD_JUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_JUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUR_CHILDREN),
+static WORD_JUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idisction"),
         dictgen::InsensitiveStr::Ascii("isdiccion"),
@@ -111832,12 +111832,12 @@ pub static WORD_JUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_JUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUP_CHILDREN),
+static WORD_JUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tier"),
         dictgen::InsensitiveStr::Ascii("yther"),
@@ -111846,12 +111846,12 @@ pub static WORD_JUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_JUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUN_CHILDREN),
+static WORD_JUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("glig"),
         dictgen::InsensitiveStr::Ascii("glign"),
@@ -111862,12 +111862,12 @@ pub static WORD_JUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_JUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUM_CHILDREN),
+static WORD_JUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("oed"),
@@ -111878,34 +111878,34 @@ pub static WORD_JUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_JUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUL_CHILDREN),
+static WORD_JUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("i")],
     values: &[&["july"]],
     range: 1..=1,
 };
 
-static WORD_JUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUI_CHILDREN),
+static WORD_JUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pter")],
     values: &[&["jupiter"]],
     range: 4..=4,
 };
 
-static WORD_JUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUG_CHILDREN),
+static WORD_JUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dement"),
         dictgen::InsensitiveStr::Ascii("demental"),
@@ -111949,12 +111949,12 @@ pub static WORD_JUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_JUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUD_CHILDREN),
+static WORD_JUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aisim"),
         dictgen::InsensitiveStr::Ascii("asim"),
@@ -111996,12 +111996,12 @@ pub static WORD_JUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_JUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JUA_CHILDREN),
+static WORD_JUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_JUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daism"),
         dictgen::InsensitiveStr::Ascii("dism"),
@@ -112010,12 +112010,12 @@ pub static WORD_JUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_JS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JS_CHILDREN),
+static WORD_JS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JS_CHILDREN),
     value: None,
 };
 
-pub static WORD_JS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cipt"),
         dictgen::InsensitiveStr::Ascii("tu"),
@@ -112026,12 +112026,12 @@ pub static WORD_JS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_JP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JP_CHILDREN),
+static WORD_JP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JP_CHILDREN),
     value: None,
 };
 
-pub static WORD_JP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -112040,12 +112040,12 @@ pub static WORD_JP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_JO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JO_CHILDREN),
+static WORD_JO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JO_CHILDREN),
     value: None,
 };
 
-pub static WORD_JO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anthan"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -112165,45 +112165,45 @@ pub static WORD_JO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=13,
 };
 
-static WORD_JN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JN_CHILDREN),
+static WORD_JN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JN_CHILDREN),
     value: None,
 };
 
-pub static WORD_JN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iw")],
     values: &[&["know"]],
     range: 2..=2,
 };
 
-static WORD_JK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JK_CHILDREN),
+static WORD_JK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JK_CHILDREN),
     value: None,
 };
 
-pub static WORD_JK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["jdk"]],
     range: 1..=1,
 };
 
-static WORD_JJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JJ_CHILDREN),
+static WORD_JJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_JJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ust")],
     values: &[&["just"]],
     range: 3..=3,
 };
 
-static WORD_JI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JI_CHILDREN),
+static WORD_JI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JI_CHILDREN),
     value: None,
 };
 
-pub static WORD_JI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("st"),
@@ -112214,23 +112214,23 @@ pub static WORD_JI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_JH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JH_CHILDREN),
+static WORD_JH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JH_CHILDREN),
     value: None,
 };
 
-pub static WORD_JH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ondoe")],
     values: &[&["johndoe"]],
     range: 5..=5,
 };
 
-static WORD_JE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JE_CHILDREN),
+static WORD_JE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JE_CHILDREN),
     value: None,
 };
 
-pub static WORD_JE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apardy"),
         dictgen::InsensitiveStr::Ascii("fferry"),
@@ -112304,12 +112304,12 @@ pub static WORD_JE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_JA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_JA_CHILDREN),
+static WORD_JA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_JA_CHILDREN),
     value: None,
 };
 
-pub static WORD_JA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_JA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckonsville"),
         dictgen::InsensitiveStr::Ascii("cksonvile"),
@@ -112427,12 +112427,12 @@ pub static WORD_JA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_I_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_I_CHILDREN),
+static WORD_I_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_I_CHILDREN),
     value: None,
 };
 
-static WORD_I_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_I_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IA_NODE),
     Some(&WORD_IB_NODE),
     Some(&WORD_IC_NODE),
@@ -112461,23 +112461,23 @@ static WORD_I_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IY_CHILDREN),
+static WORD_IY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IY_CHILDREN),
     value: Some(&["it"]),
 };
 
-pub static WORD_IY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_IW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IW_CHILDREN),
+static WORD_IW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IW_CHILDREN),
     value: None,
 };
 
-pub static WORD_IW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ht"),
         dictgen::InsensitiveStr::Ascii("ithout"),
@@ -112488,12 +112488,12 @@ pub static WORD_IW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_IV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IV_CHILDREN),
+static WORD_IV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IV_CHILDREN),
     value: None,
 };
 
-pub static WORD_IV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alid"),
         dictgen::InsensitiveStr::Ascii("entory"),
@@ -112515,23 +112515,23 @@ pub static WORD_IV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_IU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IU_CHILDREN),
+static WORD_IU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IU_CHILDREN),
     value: None,
 };
 
-pub static WORD_IU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nior")],
     values: &[&["junior"]],
     range: 4..=4,
 };
 
-static WORD_IT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IT_CHILDREN),
+static WORD_IT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IT_CHILDREN),
     value: None,
 };
 
-static WORD_IT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ITA_NODE),
     None,
     None,
@@ -112560,12 +112560,12 @@ static WORD_IT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ITT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITT_CHILDREN),
+static WORD_ITT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erable"),
         dictgen::InsensitiveStr::Ascii("erate"),
@@ -112593,12 +112593,12 @@ pub static WORD_ITT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_ITS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITS_CHILDREN),
+static WORD_ITS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ef"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -112626,12 +112626,12 @@ pub static WORD_ITS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ITN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITN_CHILDREN),
+static WORD_ITN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erest"),
         dictgen::InsensitiveStr::Ascii("erface"),
@@ -112667,12 +112667,12 @@ pub static WORD_ITN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_ITM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITM_CHILDREN),
+static WORD_ITM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -112681,12 +112681,12 @@ pub static WORD_ITM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_ITI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITI_CHILDREN),
+static WORD_ITI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alise"),
         dictgen::InsensitiveStr::Ascii("alised"),
@@ -112712,12 +112712,12 @@ pub static WORD_ITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_ITH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITH_CHILDREN),
+static WORD_ITH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eir"),
@@ -112727,12 +112727,12 @@ pub static WORD_ITH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_ITE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITE_CHILDREN),
+static WORD_ITE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arates"),
         dictgen::InsensitiveStr::Ascii("artor"),
@@ -112850,12 +112850,12 @@ pub static WORD_ITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ITA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ITA_CHILDREN),
+static WORD_ITA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ITA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ITA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ITA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lains"),
         dictgen::InsensitiveStr::Ascii("lianas"),
@@ -112873,12 +112873,12 @@ pub static WORD_ITA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_IS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IS_CHILDREN),
+static WORD_IS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IS_CHILDREN),
     value: None,
 };
 
-static WORD_IS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ISA_NODE),
     None,
     Some(&WORD_ISC_NODE),
@@ -112907,12 +112907,12 @@ static WORD_IS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ISU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISU_CHILDREN),
+static WORD_ISU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -112922,12 +112922,12 @@ pub static WORD_ISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_IST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IST_CHILDREN),
+static WORD_IST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IST_CHILDREN),
     value: Some(&["is", "it", "its", "sit", "list"]),
 };
 
-pub static WORD_IST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alling"),
         dictgen::InsensitiveStr::Ascii("ambul"),
@@ -112959,12 +112959,12 @@ pub static WORD_IST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ISS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISS_CHILDREN),
+static WORD_ISS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -112994,12 +112994,12 @@ pub static WORD_ISS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ISR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISR_CHILDREN),
+static WORD_ISR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeliens"),
         dictgen::InsensitiveStr::Ascii("aelies"),
@@ -113027,12 +113027,12 @@ pub static WORD_ISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_ISP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISP_CHILDREN),
+static WORD_ISP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atches"),
         dictgen::InsensitiveStr::Ascii("lay"),
@@ -113042,12 +113042,12 @@ pub static WORD_ISP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_ISO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISO_CHILDREN),
+static WORD_ISO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("latie"),
         dictgen::InsensitiveStr::Ascii("loated"),
@@ -113057,12 +113057,12 @@ pub static WORD_ISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_ISN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISN_CHILDREN),
+static WORD_ISN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("piron"),
@@ -113108,12 +113108,12 @@ pub static WORD_ISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_ISM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISM_CHILDREN),
+static WORD_ISM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alist"),
         dictgen::InsensitiveStr::Ascii("as"),
@@ -113122,12 +113122,12 @@ pub static WORD_ISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ISL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISL_CHILDREN),
+static WORD_ISL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adn"),
         dictgen::InsensitiveStr::Ascii("amisist"),
@@ -113167,23 +113167,23 @@ pub static WORD_ISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ISI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISI_CHILDREN),
+static WORD_ISI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("milar")],
     values: &[&["similar"]],
     range: 5..=5,
 };
 
-static WORD_ISE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISE_CHILDREN),
+static WORD_ISE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lf"),
         dictgen::InsensitiveStr::Ascii("lfe"),
@@ -113194,23 +113194,23 @@ pub static WORD_ISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ISD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISD_CHILDREN),
+static WORD_ISD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("efinitely")],
     values: &[&["indefinitely"]],
     range: 9..=9,
 };
 
-static WORD_ISC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISC_CHILDREN),
+static WORD_ISC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onnection"),
         dictgen::InsensitiveStr::Ascii("rated"),
@@ -113219,12 +113219,12 @@ pub static WORD_ISC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_ISA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ISA_CHILDREN),
+static WORD_ISA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ISA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ISA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lha"),
         dictgen::InsensitiveStr::Ascii("lmic"),
@@ -113246,12 +113246,12 @@ pub static WORD_ISA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_IR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IR_CHILDREN),
+static WORD_IR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IR_CHILDREN),
     value: None,
 };
 
-static WORD_IR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IRA_NODE),
     None,
     None,
@@ -113280,12 +113280,12 @@ static WORD_IR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRR_CHILDREN),
+static WORD_IRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acional"),
         dictgen::InsensitiveStr::Ascii("adate"),
@@ -113417,12 +113417,12 @@ pub static WORD_IRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_IRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRO_CHILDREN),
+static WORD_IRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("namn"),
         dictgen::InsensitiveStr::Ascii("ncially"),
@@ -113438,23 +113438,23 @@ pub static WORD_IRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_IRL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRL_CHILDREN),
+static WORD_IRL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRL_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eand")],
     values: &[&["ireland"]],
     range: 4..=4,
 };
 
-static WORD_IRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRI_CHILDREN),
+static WORD_IRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tate"),
@@ -113470,12 +113470,12 @@ pub static WORD_IRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_IRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRE_CHILDREN),
+static WORD_IRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctory"),
         dictgen::InsensitiveStr::Ascii("elevant"),
@@ -113499,12 +113499,12 @@ pub static WORD_IRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_IRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IRA_CHILDREN),
+static WORD_IRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nain"),
         dictgen::InsensitiveStr::Ascii("nains"),
@@ -113524,12 +113524,12 @@ pub static WORD_IRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_IP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IP_CHILDREN),
+static WORD_IP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IP_CHILDREN),
     value: None,
 };
 
-pub static WORD_IP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lementation"),
         dictgen::InsensitiveStr::Ascii("mrovement"),
@@ -113547,12 +113547,12 @@ pub static WORD_IP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_IO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IO_CHILDREN),
+static WORD_IO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clt"),
         dictgen::InsensitiveStr::Ascii("maped"),
@@ -113570,12 +113570,12 @@ pub static WORD_IO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_IN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IN_CHILDREN),
+static WORD_IN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IN_CHILDREN),
     value: None,
 };
 
-static WORD_IN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INA_NODE),
     Some(&WORD_INB_NODE),
     Some(&WORD_INC_NODE),
@@ -113604,12 +113604,12 @@ static WORD_IN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INV_CHILDREN),
+static WORD_INV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INV_CHILDREN),
     value: None,
 };
 
-static WORD_INV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INVA_NODE),
     None,
     None,
@@ -113638,12 +113638,12 @@ static WORD_INV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INVU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVU_CHILDREN),
+static WORD_INVU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lenrable"),
         dictgen::InsensitiveStr::Ascii("lernable"),
@@ -113673,12 +113673,12 @@ pub static WORD_INVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_INVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVO_CHILDREN),
+static WORD_INVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caition"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -113758,12 +113758,12 @@ pub static WORD_INVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVL_CHILDREN),
+static WORD_INVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aid"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -113787,12 +113787,12 @@ pub static WORD_INVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVI_CHILDREN),
+static WORD_INVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cation"),
@@ -113878,12 +113878,12 @@ pub static WORD_INVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INVE_CHILDREN),
+static WORD_INVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INVE_CHILDREN),
     value: None,
 };
 
-static WORD_INVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INVE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -113912,12 +113912,12 @@ static WORD_INVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INVET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVET_CHILDREN),
+static WORD_INVET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVET_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ory"),
@@ -113926,12 +113926,12 @@ pub static WORD_INVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_INVES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVES_CHILDREN),
+static WORD_INVES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVES_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itgate"),
         dictgen::InsensitiveStr::Ascii("itgated"),
@@ -114041,12 +114041,12 @@ pub static WORD_INVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_INVER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVER_CHILDREN),
+static WORD_INVER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVER_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("als"),
@@ -114088,12 +114088,12 @@ pub static WORD_INVER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_INVEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVEN_CHILDREN),
+static WORD_INVEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sions"),
         dictgen::InsensitiveStr::Ascii("tario"),
@@ -114123,12 +114123,12 @@ pub static WORD_INVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_INVEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVEI_CHILDREN),
+static WORD_INVEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tably"),
@@ -114137,12 +114137,12 @@ pub static WORD_INVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_INVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INVA_CHILDREN),
+static WORD_INVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deras"),
         dictgen::InsensitiveStr::Ascii("derats"),
@@ -114232,12 +114232,12 @@ pub static WORD_INVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INU_CHILDREN),
+static WORD_INU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dstry"),
         dictgen::InsensitiveStr::Ascii("ition"),
@@ -114261,12 +114261,12 @@ pub static WORD_INU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_INT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INT_CHILDREN),
+static WORD_INT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INT_CHILDREN),
     value: None,
 };
 
-static WORD_INT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTA_NODE),
     None,
     None,
@@ -114295,12 +114295,12 @@ static WORD_INT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTU_CHILDREN),
+static WORD_INTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("atively"),
@@ -114338,12 +114338,12 @@ pub static WORD_INTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_INTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTT_CHILDREN),
+static WORD_INTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("errupt"),
         dictgen::InsensitiveStr::Ascii("erupt"),
@@ -114361,12 +114361,12 @@ pub static WORD_INTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_INTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTS_CHILDREN),
+static WORD_INTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("alled"),
@@ -114406,12 +114406,12 @@ pub static WORD_INTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_INTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTR_CHILDREN),
+static WORD_INTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTR_CHILDREN),
     value: None,
 };
 
-static WORD_INTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTRA_NODE),
     None,
     Some(&WORD_INTRC_NODE),
@@ -114440,12 +114440,12 @@ static WORD_INTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRU_CHILDREN),
+static WORD_INTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -114485,12 +114485,12 @@ pub static WORD_INTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INTRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRR_CHILDREN),
+static WORD_INTRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("upt"),
         dictgen::InsensitiveStr::Ascii("upted"),
@@ -114506,12 +114506,12 @@ pub static WORD_INTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_INTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRO_CHILDREN),
+static WORD_INTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("decks"),
         dictgen::InsensitiveStr::Ascii("diced"),
@@ -114607,12 +114607,12 @@ pub static WORD_INTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_INTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRI_CHILDREN),
+static WORD_INTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caces"),
         dictgen::InsensitiveStr::Ascii("casies"),
@@ -114678,12 +114678,12 @@ pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRE_CHILDREN),
+static WORD_INTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cacies"),
         dictgen::InsensitiveStr::Ascii("eg"),
@@ -114751,34 +114751,34 @@ pub static WORD_INTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_INTRD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRD_CHILDREN),
+static WORD_INTRD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uced")],
     values: &[&["introduced"]],
     range: 4..=4,
 };
 
-static WORD_INTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRC_CHILDREN),
+static WORD_INTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utions")],
     values: &[&["instructions"]],
     range: 6..=6,
 };
 
-static WORD_INTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTRA_CHILDREN),
+static WORD_INTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cacies"),
         dictgen::InsensitiveStr::Ascii("cicies"),
@@ -114802,12 +114802,12 @@ pub static WORD_INTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_INTQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTQ_CHILDREN),
+static WORD_INTQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uire"),
         dictgen::InsensitiveStr::Ascii("uired"),
@@ -114825,12 +114825,12 @@ pub static WORD_INTQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INTP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTP_CHILDREN),
+static WORD_INTP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("reter"),
         dictgen::InsensitiveStr::Ascii("ut"),
@@ -114840,12 +114840,12 @@ pub static WORD_INTP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTO_CHILDREN),
+static WORD_INTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("larant"),
         dictgen::InsensitiveStr::Ascii("lerace"),
@@ -114913,12 +114913,12 @@ pub static WORD_INTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_INTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTI_CHILDREN),
+static WORD_INTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTI_CHILDREN),
     value: None,
 };
 
-static WORD_INTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTIA_NODE),
     None,
     Some(&WORD_INTIC_NODE),
@@ -114947,12 +114947,12 @@ static WORD_INTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIU_CHILDREN),
+static WORD_INTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tive"),
@@ -114962,12 +114962,12 @@ pub static WORD_INTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIT_CHILDREN),
+static WORD_INTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -114989,34 +114989,34 @@ pub static WORD_INTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIR_CHILDREN),
+static WORD_INTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cate")],
     values: &[&["intricate"]],
     range: 4..=4,
 };
 
-static WORD_INTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIN_CHILDREN),
+static WORD_INTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ite")],
     values: &[&["infinite"]],
     range: 3..=3,
 };
 
-static WORD_INTIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIM_CHILDREN),
+static WORD_INTIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adate"),
         dictgen::InsensitiveStr::Ascii("adated"),
@@ -115082,12 +115082,12 @@ pub static WORD_INTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INTIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIL_CHILDREN),
+static WORD_INTIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ising"),
         dictgen::InsensitiveStr::Ascii("ize"),
@@ -115107,12 +115107,12 @@ pub static WORD_INTIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INTII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTII_CHILDREN),
+static WORD_INTII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTII_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alise"),
@@ -115128,23 +115128,23 @@ pub static WORD_INTII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INTIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIG_CHILDREN),
+static WORD_INTIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["integer"]],
     range: 2..=2,
 };
 
-static WORD_INTID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTID_CHILDREN),
+static WORD_INTID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTID_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imate"),
         dictgen::InsensitiveStr::Ascii("imation"),
@@ -115153,12 +115153,12 @@ pub static WORD_INTID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIC_CHILDREN),
+static WORD_INTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("racies"),
@@ -115168,12 +115168,12 @@ pub static WORD_INTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTIA_CHILDREN),
+static WORD_INTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilise"),
         dictgen::InsensitiveStr::Ascii("ilised"),
@@ -115293,12 +115293,12 @@ pub static WORD_INTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INTG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTG_CHILDREN),
+static WORD_INTG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -115308,12 +115308,12 @@ pub static WORD_INTG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_INTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTE_CHILDREN),
+static WORD_INTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTE_CHILDREN),
     value: None,
 };
 
-static WORD_INTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTEA_NODE),
     None,
     Some(&WORD_INTEC_NODE),
@@ -115342,12 +115342,12 @@ static WORD_INTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEV_CHILDREN),
+static WORD_INTEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("als"),
@@ -115363,12 +115363,12 @@ pub static WORD_INTEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_INTES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTES_CHILDREN),
+static WORD_INTES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTES_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ection"),
         dictgen::InsensitiveStr::Ascii("ections"),
@@ -115400,12 +115400,12 @@ pub static WORD_INTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INTER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTER_CHILDREN),
+static WORD_INTER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTER_CHILDREN),
     value: None,
 };
 
-static WORD_INTER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTERA_NODE),
     Some(&WORD_INTERB_NODE),
     Some(&WORD_INTERC_NODE),
@@ -115434,12 +115434,12 @@ static WORD_INTER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTERW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERW_CHILDREN),
+static WORD_INTERW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERW_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebbs"),
         dictgen::InsensitiveStr::Ascii("ebers"),
@@ -115449,12 +115449,12 @@ pub static WORD_INTERW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_INTERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERV_CHILDREN),
+static WORD_INTERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("alles"),
@@ -115542,12 +115542,12 @@ pub static WORD_INTERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_INTERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERU_CHILDREN),
+static WORD_INTERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("ptable"),
@@ -115571,12 +115571,12 @@ pub static WORD_INTERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_INTERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERT_CHILDREN),
+static WORD_INTERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ained"),
         dictgen::InsensitiveStr::Ascii("aining"),
@@ -115604,12 +115604,12 @@ pub static WORD_INTERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_INTERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERS_CHILDREN),
+static WORD_INTERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cetion"),
         dictgen::InsensitiveStr::Ascii("eccion"),
@@ -115697,12 +115697,12 @@ pub static WORD_INTERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_INTERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERR_CHILDREN),
+static WORD_INTERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("accial"),
         dictgen::InsensitiveStr::Ascii("act"),
@@ -115800,12 +115800,12 @@ pub static WORD_INTERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_INTERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTERP_CHILDREN),
+static WORD_INTERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTERP_CHILDREN),
     value: None,
 };
 
-static WORD_INTERP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTERP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -115834,12 +115834,12 @@ static WORD_INTERP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTERPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERPR_CHILDREN),
+static WORD_INTERPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atation"),
         dictgen::InsensitiveStr::Ascii("atations"),
@@ -115935,12 +115935,12 @@ pub static WORD_INTERPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=9,
 };
 
-static WORD_INTERPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERPO_CHILDREN),
+static WORD_INTERPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laed"),
         dictgen::InsensitiveStr::Ascii("laion"),
@@ -115982,12 +115982,12 @@ pub static WORD_INTERPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=8,
 };
 
-static WORD_INTERPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERPL_CHILDREN),
+static WORD_INTERPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("oate"),
@@ -116009,12 +116009,12 @@ pub static WORD_INTERPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=7,
 };
 
-static WORD_INTERPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERPE_CHILDREN),
+static WORD_INTERPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rated"),
         dictgen::InsensitiveStr::Ascii("reters"),
@@ -116062,12 +116062,12 @@ pub static WORD_INTERPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_INTERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERO_CHILDREN),
+static WORD_INTERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gate"),
         dictgen::InsensitiveStr::Ascii("gation"),
@@ -116089,12 +116089,12 @@ pub static WORD_INTERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=9,
 };
 
-static WORD_INTERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERN_CHILDREN),
+static WORD_INTERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acional"),
         dictgen::InsensitiveStr::Ascii("all"),
@@ -116186,12 +116186,12 @@ pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=11,
 };
 
-static WORD_INTERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERM_CHILDREN),
+static WORD_INTERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERM_CHILDREN),
     value: Some(&["interim", "intern"]),
 };
 
-pub static WORD_INTERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edate"),
         dictgen::InsensitiveStr::Ascii("ediare"),
@@ -116235,12 +116235,12 @@ pub static WORD_INTERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_INTERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERL_CHILDREN),
+static WORD_INTERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("eaed"),
@@ -116266,12 +116266,12 @@ pub static WORD_INTERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_INTERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERI_CHILDREN),
+static WORD_INTERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oara"),
         dictgen::InsensitiveStr::Ascii("oare"),
@@ -116297,12 +116297,12 @@ pub static WORD_INTERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_INTERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERG_CHILDREN),
+static WORD_INTERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -116342,12 +116342,12 @@ pub static WORD_INTERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_INTERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERF_CHILDREN),
+static WORD_INTERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acce"),
         dictgen::InsensitiveStr::Ascii("act"),
@@ -116425,12 +116425,12 @@ pub static WORD_INTERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_INTERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INTERE_CHILDREN),
+static WORD_INTERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INTERE_CHILDREN),
     value: None,
 };
 
-static WORD_INTERE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INTERE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INTEREA_NODE),
     None,
     Some(&WORD_INTEREC_NODE),
@@ -116459,34 +116459,34 @@ static WORD_INTERE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INTEREW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREW_CHILDREN),
+static WORD_INTEREW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREW_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bs")],
     values: &[&["interwebs"]],
     range: 2..=2,
 };
 
-static WORD_INTEREV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREV_CHILDREN),
+static WORD_INTEREV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iew")],
     values: &[&["interview"]],
     range: 3..=3,
 };
 
-static WORD_INTERET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERET_CHILDREN),
+static WORD_INTERET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERET_CHILDREN),
     value: Some(&["interest"]),
 };
 
-pub static WORD_INTERET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("sed"),
@@ -116495,12 +116495,12 @@ pub static WORD_INTERET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=3,
 };
 
-static WORD_INTERES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERES_CHILDREN),
+static WORD_INTERES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERES_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -116570,12 +116570,12 @@ pub static WORD_INTERES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_INTERER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERER_CHILDREN),
+static WORD_INTERER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERER_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sted"),
         dictgen::InsensitiveStr::Ascii("sting"),
@@ -116584,12 +116584,12 @@ pub static WORD_INTERER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=5,
 };
 
-static WORD_INTEREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREP_CHILDREN),
+static WORD_INTEREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREP_CHILDREN),
     value: Some(&["interop"]),
 };
 
-pub static WORD_INTEREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eted"),
         dictgen::InsensitiveStr::Ascii("olate"),
@@ -116623,12 +116623,12 @@ pub static WORD_INTEREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_INTEREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREN_CHILDREN),
+static WORD_INTEREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -116637,12 +116637,12 @@ pub static WORD_INTEREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=2,
 };
 
-static WORD_INTEREL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREL_CHILDREN),
+static WORD_INTEREL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("aved"),
@@ -116651,12 +116651,12 @@ pub static WORD_INTEREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=4,
 };
 
-static WORD_INTEREF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREF_CHILDREN),
+static WORD_INTEREF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erence"),
         dictgen::InsensitiveStr::Ascii("erences"),
@@ -116666,34 +116666,34 @@ pub static WORD_INTEREF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=7,
 };
 
-static WORD_INTEREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREE_CHILDREN),
+static WORD_INTEREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sted")],
     values: &[&["interested"]],
     range: 4..=4,
 };
 
-static WORD_INTERED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERED_CHILDREN),
+static WORD_INTERED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERED_CHILDREN),
     value: Some(&["interred", "interned"]),
 };
 
-pub static WORD_INTERED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_INTEREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREC_CHILDREN),
+static WORD_INTEREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ptor"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -116717,12 +116717,12 @@ pub static WORD_INTEREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_INTEREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEREA_CHILDREN),
+static WORD_INTEREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -116738,12 +116738,12 @@ pub static WORD_INTEREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_INTERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERD_CHILDREN),
+static WORD_INTERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ependant"),
         dictgen::InsensitiveStr::Ascii("ependecies"),
@@ -116752,12 +116752,12 @@ pub static WORD_INTERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 8..=10,
 };
 
-static WORD_INTERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERC_CHILDREN),
+static WORD_INTERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahnge"),
         dictgen::InsensitiveStr::Ascii("ahnged"),
@@ -116819,23 +116819,23 @@ pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_INTERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERB_CHILDREN),
+static WORD_INTERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("read")],
     values: &[&["interbreed", "interbred"]],
     range: 4..=4,
 };
 
-static WORD_INTERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTERA_CHILDREN),
+static WORD_INTERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -116969,12 +116969,12 @@ pub static WORD_INTERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_INTEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEP_CHILDREN),
+static WORD_INTEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("olate"),
         dictgen::InsensitiveStr::Ascii("olated"),
@@ -117016,12 +117016,12 @@ pub static WORD_INTEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INTEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEN_CHILDREN),
+static WORD_INTEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -117101,23 +117101,23 @@ pub static WORD_INTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_INTEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEM_CHILDREN),
+static WORD_INTEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ediary")],
     values: &[&["intermediary"]],
     range: 6..=6,
 };
 
-static WORD_INTEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEL_CHILDREN),
+static WORD_INTEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eaved"),
         dictgen::InsensitiveStr::Ascii("ectual"),
@@ -117203,12 +117203,12 @@ pub static WORD_INTEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_INTEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEG_CHILDREN),
+static WORD_INTEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arte"),
         dictgen::InsensitiveStr::Ascii("arted"),
@@ -117276,12 +117276,12 @@ pub static WORD_INTEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INTEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEF_CHILDREN),
+static WORD_INTEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -117305,23 +117305,23 @@ pub static WORD_INTEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_INTEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEE_CHILDREN),
+static WORD_INTEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gration")],
     values: &[&["integration"]],
     range: 7..=7,
 };
 
-static WORD_INTED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTED_CHILDREN),
+static WORD_INTED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTED_CHILDREN),
     value: Some(&["inetd", "intend"]),
 };
 
-pub static WORD_INTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -117330,12 +117330,12 @@ pub static WORD_INTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_INTEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEC_CHILDREN),
+static WORD_INTEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("epted"),
         dictgen::InsensitiveStr::Ascii("epting"),
@@ -117344,12 +117344,12 @@ pub static WORD_INTEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_INTEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTEA_CHILDREN),
+static WORD_INTEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -117358,23 +117358,23 @@ pub static WORD_INTEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_INTD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTD_CHILDREN),
+static WORD_INTD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icating")],
     values: &[&["indicating"]],
     range: 7..=7,
 };
 
-static WORD_INTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INTA_CHILDREN),
+static WORD_INTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ces"),
         dictgen::InsensitiveStr::Ascii("ck"),
@@ -117438,12 +117438,12 @@ pub static WORD_INTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_INS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INS_CHILDREN),
+static WORD_INS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INS_CHILDREN),
     value: None,
 };
 
-static WORD_INS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSA_NODE),
     None,
     Some(&WORD_INSC_NODE),
@@ -117472,12 +117472,12 @@ static WORD_INS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSU_CHILDREN),
+static WORD_INSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alted"),
         dictgen::InsensitiveStr::Ascii("bstantiated"),
@@ -117553,12 +117553,12 @@ pub static WORD_INSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_INST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INST_CHILDREN),
+static WORD_INST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INST_CHILDREN),
     value: None,
 };
 
-static WORD_INST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSTA_NODE),
     None,
     None,
@@ -117587,12 +117587,12 @@ static WORD_INST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTU_CHILDREN),
+static WORD_INSTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -117648,12 +117648,12 @@ pub static WORD_INSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_INSTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTT_CHILDREN),
+static WORD_INSTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ruction"),
         dictgen::InsensitiveStr::Ascii("uction"),
@@ -117662,12 +117662,12 @@ pub static WORD_INSTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_INSTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTS_CHILDREN),
+static WORD_INSTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("all"),
         dictgen::InsensitiveStr::Ascii("allation"),
@@ -117685,12 +117685,12 @@ pub static WORD_INSTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INSTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INSTR_CHILDREN),
+static WORD_INSTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INSTR_CHILDREN),
     value: None,
 };
 
-static WORD_INSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INSTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSTRA_NODE),
     None,
     Some(&WORD_INSTRC_NODE),
@@ -117719,12 +117719,12 @@ static WORD_INSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRU_CHILDREN),
+static WORD_INSTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("ccional"),
@@ -117820,23 +117820,23 @@ pub static WORD_INSTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=10,
 };
 
-static WORD_INSTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRO_CHILDREN),
+static WORD_INSTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("spection")],
     values: &[&["introspection"]],
     range: 8..=8,
 };
 
-static WORD_INSTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRI_CHILDREN),
+static WORD_INSTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("nics"),
@@ -117852,23 +117852,23 @@ pub static WORD_INSTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_INSTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRE_CHILDREN),
+static WORD_INSTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ad")],
     values: &[&["instead"]],
     range: 2..=2,
 };
 
-static WORD_INSTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRC_CHILDREN),
+static WORD_INSTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tional"),
@@ -117900,12 +117900,12 @@ pub static WORD_INSTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_INSTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTRA_CHILDREN),
+static WORD_INSTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -117929,12 +117929,12 @@ pub static WORD_INSTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_INSTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTN_CHILDREN),
+static WORD_INSTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -117972,12 +117972,12 @@ pub static WORD_INSTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_INSTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTL_CHILDREN),
+static WORD_INSTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alation"),
@@ -118013,12 +118013,12 @@ pub static WORD_INSTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_INSTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTI_CHILDREN),
+static WORD_INSTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atiate"),
         dictgen::InsensitiveStr::Ascii("cnt"),
@@ -118086,12 +118086,12 @@ pub static WORD_INSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_INSTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTE_CHILDREN),
+static WORD_INSTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("add"),
         dictgen::InsensitiveStr::Ascii("ading"),
@@ -118145,12 +118145,12 @@ pub static WORD_INSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_INSTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INSTA_CHILDREN),
+static WORD_INSTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INSTA_CHILDREN),
     value: None,
 };
 
-static WORD_INSTA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INSTA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSTAA_NODE),
     Some(&WORD_INSTAB_NODE),
     Some(&WORD_INSTAC_NODE),
@@ -118179,12 +118179,12 @@ static WORD_INSTA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSTAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAT_CHILDREN),
+static WORD_INSTAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -118206,23 +118206,23 @@ pub static WORD_INSTAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_INSTAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAS_CHILDREN),
+static WORD_INSTAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lled")],
     values: &[&["installed"]],
     range: 4..=4,
 };
 
-static WORD_INSTAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAN_CHILDREN),
+static WORD_INSTAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atiation"),
         dictgen::InsensitiveStr::Ascii("cce"),
@@ -118316,12 +118316,12 @@ pub static WORD_INSTAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_INSTAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAL_CHILDREN),
+static WORD_INSTAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("altion"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -118397,12 +118397,12 @@ pub static WORD_INSTAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_INSTAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAE_CHILDREN),
+static WORD_INSTAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -118411,23 +118411,23 @@ pub static WORD_INSTAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_INSTAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAD_CHILDREN),
+static WORD_INSTAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAD_CHILDREN),
     value: Some(&["instead"]),
 };
 
-pub static WORD_INSTAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["instead"]],
     range: 1..=1,
 };
 
-static WORD_INSTAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAC_CHILDREN),
+static WORD_INSTAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -118437,12 +118437,12 @@ pub static WORD_INSTAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_INSTAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAB_CHILDREN),
+static WORD_INSTAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("iliy"),
@@ -118460,23 +118460,23 @@ pub static WORD_INSTAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_INSTAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSTAA_CHILDREN),
+static WORD_INSTAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSTAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSTAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSTAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nce")],
     values: &[&["instance"]],
     range: 3..=3,
 };
 
-static WORD_INSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSR_CHILDREN),
+static WORD_INSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uction"),
         dictgen::InsensitiveStr::Ascii("ugency"),
@@ -118485,12 +118485,12 @@ pub static WORD_INSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_INSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSP_CHILDREN),
+static WORD_INSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("eccion"),
@@ -118548,12 +118548,12 @@ pub static WORD_INSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_INSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSO_CHILDREN),
+static WORD_INSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mina"),
         dictgen::InsensitiveStr::Ascii("nmia"),
@@ -118563,23 +118563,23 @@ pub static WORD_INSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_INSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSM_CHILDREN),
+static WORD_INSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onia")],
     values: &[&["insomnia"]],
     range: 4..=4,
 };
 
-static WORD_INSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSL_CHILDREN),
+static WORD_INSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uated"),
         dictgen::InsensitiveStr::Ascii("uts"),
@@ -118588,12 +118588,12 @@ pub static WORD_INSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_INSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSI_CHILDREN),
+static WORD_INSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dde"),
@@ -118675,12 +118675,12 @@ pub static WORD_INSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INSE_CHILDREN),
+static WORD_INSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INSE_CHILDREN),
     value: None,
 };
 
-static WORD_INSE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INSE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INSEA_NODE),
     None,
     Some(&WORD_INSEC_NODE),
@@ -118709,12 +118709,12 @@ static WORD_INSE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INSET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSET_CHILDREN),
+static WORD_INSET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSET_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("ead"),
@@ -118732,12 +118732,12 @@ pub static WORD_INSET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_INSES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSES_CHILDREN),
+static WORD_INSES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSES_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itive"),
         dictgen::InsensitiveStr::Ascii("itively"),
@@ -118753,12 +118753,12 @@ pub static WORD_INSES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_INSER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSER_CHILDREN),
+static WORD_INSER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSER_CHILDREN),
     value: Some(&["insert"]),
 };
 
-pub static WORD_INSER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -118802,12 +118802,12 @@ pub static WORD_INSER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_INSEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSEP_CHILDREN),
+static WORD_INSEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -118837,12 +118837,12 @@ pub static WORD_INSEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_INSEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSEN_CHILDREN),
+static WORD_INSEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itive"),
         dictgen::InsensitiveStr::Ascii("itively"),
@@ -118890,12 +118890,12 @@ pub static WORD_INSEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_INSEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSEC_CHILDREN),
+static WORD_INSEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tes"),
         dictgen::InsensitiveStr::Ascii("tiverous"),
@@ -118915,23 +118915,23 @@ pub static WORD_INSEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INSEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSEA_CHILDREN),
+static WORD_INSEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["instead"]],
     range: 1..=1,
 };
 
-static WORD_INSD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSD_CHILDREN),
+static WORD_INSD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ie"),
@@ -118940,12 +118940,12 @@ pub static WORD_INSD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_INSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSC_CHILDREN),
+static WORD_INSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ets"),
         dictgen::InsensitiveStr::Ascii("peting"),
@@ -118965,12 +118965,12 @@ pub static WORD_INSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INSA_CHILDREN),
+static WORD_INSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ll"),
         dictgen::InsensitiveStr::Ascii("llation"),
@@ -119000,12 +119000,12 @@ pub static WORD_INSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_INR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INR_CHILDREN),
+static WORD_INR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aged"),
         dictgen::InsensitiveStr::Ascii("ement"),
@@ -119037,12 +119037,12 @@ pub static WORD_INR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_INQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INQ_CHILDREN),
+static WORD_INQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uier"),
         dictgen::InsensitiveStr::Ascii("uirey"),
@@ -119098,12 +119098,12 @@ pub static WORD_INQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_INP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INP_CHILDREN),
+static WORD_INP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -119235,12 +119235,12 @@ pub static WORD_INP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_INO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INO_CHILDREN),
+static WORD_INO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("btrusive"),
         dictgen::InsensitiveStr::Ascii("cence"),
@@ -119280,12 +119280,12 @@ pub static WORD_INO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_INN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INN_CHILDREN),
+static WORD_INN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("accible"),
         dictgen::InsensitiveStr::Ascii("active"),
@@ -119371,12 +119371,12 @@ pub static WORD_INN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_INM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INM_CHILDREN),
+static WORD_INM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ediate"),
         dictgen::InsensitiveStr::Ascii("ediatelly"),
@@ -119406,12 +119406,12 @@ pub static WORD_INM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_INL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INL_CHILDREN),
+static WORD_INL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alid"),
         dictgen::InsensitiveStr::Ascii("cine"),
@@ -119465,12 +119465,12 @@ pub static WORD_INL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_INK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INK_CHILDREN),
+static WORD_INK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INK_CHILDREN),
     value: None,
 };
 
-pub static WORD_INK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ompatible"),
         dictgen::InsensitiveStr::Ascii("ompetence"),
@@ -119480,12 +119480,12 @@ pub static WORD_INK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=9,
 };
 
-static WORD_INJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INJ_CHILDREN),
+static WORD_INJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cetion"),
         dictgen::InsensitiveStr::Ascii("est"),
@@ -119505,12 +119505,12 @@ pub static WORD_INJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_INI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INI_CHILDREN),
+static WORD_INI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INI_CHILDREN),
     value: None,
 };
 
-static WORD_INI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INIA_NODE),
     None,
     None,
@@ -119539,12 +119539,12 @@ static WORD_INI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_INIZ_NODE),
 ];
 
-static WORD_INIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIZ_CHILDREN),
+static WORD_INIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialize"),
         dictgen::InsensitiveStr::Ascii("ialized"),
@@ -119554,23 +119554,23 @@ pub static WORD_INIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_INIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIV_CHILDREN),
+static WORD_INIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("isible")],
     values: &[&["invisible"]],
     range: 6..=6,
 };
 
-static WORD_INIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INIT_CHILDREN),
+static WORD_INIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INIT_CHILDREN),
     value: None,
 };
 
-static WORD_INIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INIT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INITA_NODE),
     None,
     None,
@@ -119599,12 +119599,12 @@ static WORD_INIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INITU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITU_CHILDREN),
+static WORD_INITU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialisation"),
         dictgen::InsensitiveStr::Ascii("ialization"),
@@ -119614,12 +119614,12 @@ pub static WORD_INITU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_INITM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITM_CHILDREN),
+static WORD_INITM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acy"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -119635,12 +119635,12 @@ pub static WORD_INITM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_INITL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITL_CHILDREN),
+static WORD_INITL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iasation"),
         dictgen::InsensitiveStr::Ascii("iase"),
@@ -119664,12 +119664,12 @@ pub static WORD_INITL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_INITI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INITI_CHILDREN),
+static WORD_INITI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INITI_CHILDREN),
     value: None,
 };
 
-static WORD_INITI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INITI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INITIA_NODE),
     None,
     None,
@@ -119698,12 +119698,12 @@ static WORD_INITI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INITIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIT_CHILDREN),
+static WORD_INITIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aive"),
         dictgen::InsensitiveStr::Ascii("alisation"),
@@ -119745,23 +119745,23 @@ pub static WORD_INITIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=11,
 };
 
-static WORD_INITIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIS_CHILDREN),
+static WORD_INITIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["initials"]],
     range: 1..=1,
 };
 
-static WORD_INITIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIL_CHILDREN),
+static WORD_INITIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aize"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -119831,12 +119831,12 @@ pub static WORD_INITIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=11,
 };
 
-static WORD_INITII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITII_CHILDREN),
+static WORD_INITII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITII_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alise"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -119845,12 +119845,12 @@ pub static WORD_INITII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=5,
 };
 
-static WORD_INITIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INITIA_CHILDREN),
+static WORD_INITIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INITIA_CHILDREN),
     value: None,
 };
 
-static WORD_INITIA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INITIA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -119879,23 +119879,23 @@ static WORD_INITIA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INITIAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIAV_CHILDREN),
+static WORD_INITIAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ite")],
     values: &[&["initiatives"]],
     range: 3..=3,
 };
 
-static WORD_INITIAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIAT_CHILDREN),
+static WORD_INITIAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -119931,12 +119931,12 @@ pub static WORD_INITIAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_INITIAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INITIAL_CHILDREN),
+static WORD_INITIAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INITIAL_CHILDREN),
     value: None,
 };
 
-static WORD_INITIAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INITIAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -119965,12 +119965,12 @@ static WORD_INITIAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_INITIALZ_NODE),
 ];
 
-static WORD_INITIALZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALZ_CHILDREN),
+static WORD_INITIALZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIALZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -119996,12 +119996,12 @@ pub static WORD_INITIALZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=5,
 };
 
-static WORD_INITIALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALY_CHILDREN),
+static WORD_INITIALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALY_CHILDREN),
     value: Some(&["initially"]),
 };
 
-pub static WORD_INITIALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -120027,12 +120027,12 @@ pub static WORD_INITIALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=4,
 };
 
-static WORD_INITIALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALS_CHILDREN),
+static WORD_INITIALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -120050,23 +120050,23 @@ pub static WORD_INITIALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=5,
 };
 
-static WORD_INITIALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALL_CHILDREN),
+static WORD_INITIALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALL_CHILDREN),
     value: Some(&["initial", "initially"]),
 };
 
-pub static WORD_INITIALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["initially"]],
     range: 2..=2,
 };
 
-static WORD_INITIALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALI_CHILDREN),
+static WORD_INITIALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alise"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -120186,23 +120186,23 @@ pub static WORD_INITIALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=7,
 };
 
-static WORD_INITIALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIALE_CHILDREN),
+static WORD_INITIALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIALE_CHILDREN),
     value: Some(&["initial"]),
 };
 
-pub static WORD_INITIALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["initials", "initialise", "initializes", "initialises"]],
     range: 1..=1,
 };
 
-static WORD_INITIAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITIAI_CHILDREN),
+static WORD_INITIAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITIAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITIAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITIAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lization"),
         dictgen::InsensitiveStr::Ascii("lize"),
@@ -120228,12 +120228,12 @@ pub static WORD_INITIAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=8,
 };
 
-static WORD_INITA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INITA_CHILDREN),
+static WORD_INITA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INITA_CHILDREN),
     value: None,
 };
 
-static WORD_INITA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INITA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -120262,12 +120262,12 @@ static WORD_INITA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INITAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITAT_CHILDREN),
+static WORD_INITAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -120295,12 +120295,12 @@ pub static WORD_INITAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_INITAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITAL_CHILDREN),
+static WORD_INITAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITAL_CHILDREN),
     value: Some(&["initial"]),
 };
 
-pub static WORD_INITAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -120366,12 +120366,12 @@ pub static WORD_INITAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_INITAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INITAI_CHILDREN),
+static WORD_INITAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INITAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INITAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INITAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lisation"),
@@ -120437,12 +120437,12 @@ pub static WORD_INITAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_INIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIS_CHILDREN),
+static WORD_INIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghts"),
         dictgen::InsensitiveStr::Ascii("ialise"),
@@ -120462,12 +120462,12 @@ pub static WORD_INIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ININ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ININ_CHILDREN),
+static WORD_ININ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ININ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ININ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ININ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ite"),
         dictgen::InsensitiveStr::Ascii("telligent"),
@@ -120489,23 +120489,23 @@ pub static WORD_ININ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_INIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIL_CHILDREN),
+static WORD_INIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ne")],
     values: &[&["inline"]],
     range: 2..=2,
 };
 
-static WORD_INII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INII_CHILDREN),
+static WORD_INII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INII_CHILDREN),
     value: None,
 };
 
-pub static WORD_INII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("talize"),
         dictgen::InsensitiveStr::Ascii("talized"),
@@ -120531,12 +120531,12 @@ pub static WORD_INII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_INIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIF_CHILDREN),
+static WORD_INIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inite"),
         dictgen::InsensitiveStr::Ascii("inity"),
@@ -120558,12 +120558,12 @@ pub static WORD_INIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_INIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIE_CHILDREN),
+static WORD_INIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -120581,12 +120581,12 @@ pub static WORD_INIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INID_CHILDREN),
+static WORD_INID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INID_CHILDREN),
     value: None,
 };
 
-pub static WORD_INID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ans"),
         dictgen::InsensitiveStr::Ascii("cates"),
@@ -120616,12 +120616,12 @@ pub static WORD_INID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_INIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INIA_CHILDREN),
+static WORD_INIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lization"),
         dictgen::InsensitiveStr::Ascii("lize"),
@@ -120641,12 +120641,12 @@ pub static WORD_INIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INH_CHILDREN),
+static WORD_INH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INH_CHILDREN),
     value: Some(&["in"]),
 };
 
-pub static WORD_INH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abitans"),
         dictgen::InsensitiveStr::Ascii("abitat"),
@@ -120756,12 +120756,12 @@ pub static WORD_INH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_ING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ING_CHILDREN),
+static WORD_ING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ING_CHILDREN),
     value: None,
 };
 
-pub static WORD_ING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eger"),
         dictgen::InsensitiveStr::Ascii("egral"),
@@ -120835,12 +120835,12 @@ pub static WORD_ING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_INF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INF_CHILDREN),
+static WORD_INF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INF_CHILDREN),
     value: None,
 };
 
-static WORD_INF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INFA_NODE),
     None,
     None,
@@ -120869,12 +120869,12 @@ static WORD_INF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFU_CHILDREN),
+static WORD_INFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lenced"),
         dictgen::InsensitiveStr::Ascii("lences"),
@@ -120884,12 +120884,12 @@ pub static WORD_INFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_INFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFR_CHILDREN),
+static WORD_INFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antryman"),
         dictgen::InsensitiveStr::Ascii("aread"),
@@ -120981,12 +120981,12 @@ pub static WORD_INFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_INFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFO_CHILDREN),
+static WORD_INFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emation"),
         dictgen::InsensitiveStr::Ascii("grahic"),
@@ -121120,12 +121120,12 @@ pub static WORD_INFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFL_CHILDREN),
+static WORD_INFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amable"),
         dictgen::InsensitiveStr::Ascii("amation"),
@@ -121213,12 +121213,12 @@ pub static WORD_INFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_INFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFI_CHILDREN),
+static WORD_INFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deltiy"),
         dictgen::InsensitiveStr::Ascii("dility"),
@@ -121310,12 +121310,12 @@ pub static WORD_INFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFE_CHILDREN),
+static WORD_INFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccious"),
         dictgen::InsensitiveStr::Ascii("ctation"),
@@ -121377,12 +121377,12 @@ pub static WORD_INFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_INFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INFA_CHILDREN),
+static WORD_INFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("illible"),
         dictgen::InsensitiveStr::Ascii("lability"),
@@ -121422,12 +121422,12 @@ pub static WORD_INFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INE_CHILDREN),
+static WORD_INE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INE_CHILDREN),
     value: Some(&["one"]),
 };
 
-static WORD_INE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INEA_NODE),
     None,
     None,
@@ -121456,12 +121456,12 @@ static WORD_INE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEX_CHILDREN),
+static WORD_INEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEX_CHILDREN),
     value: Some(&["index"]),
 };
 
-pub static WORD_INEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blicably"),
         dictgen::InsensitiveStr::Ascii("eprienced"),
@@ -121531,12 +121531,12 @@ pub static WORD_INEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_INEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEV_CHILDREN),
+static WORD_INEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atible"),
         dictgen::InsensitiveStr::Ascii("etable"),
@@ -121578,23 +121578,23 @@ pub static WORD_INEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_INET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INET_CHILDREN),
+static WORD_INET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INET_CHILDREN),
     value: None,
 };
 
-pub static WORD_INET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rrupts")],
     values: &[&["interrupts"]],
     range: 6..=6,
 };
 
-static WORD_INES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INES_CHILDREN),
+static WORD_INES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INES_CHILDREN),
     value: Some(&["lines"]),
 };
 
-pub static WORD_INES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rted"),
         dictgen::InsensitiveStr::Ascii("tart"),
@@ -121603,12 +121603,12 @@ pub static WORD_INES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_INER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INER_CHILDREN),
+static WORD_INER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INER_CHILDREN),
     value: None,
 };
 
-pub static WORD_INER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("face"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -121652,12 +121652,12 @@ pub static WORD_INER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEQ_CHILDREN),
+static WORD_INEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ality"),
         dictgen::InsensitiveStr::Ascii("aulity"),
@@ -121675,45 +121675,45 @@ pub static WORD_INEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEN_CHILDREN),
+static WORD_INEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tory")],
     values: &[&["inventory"]],
     range: 4..=4,
 };
 
-static WORD_INEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEL_CHILDREN),
+static WORD_INEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ligible")],
     values: &[&["ineligible"]],
     range: 7..=7,
 };
 
-static WORD_INEJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEJ_CHILDREN),
+static WORD_INEJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ction")],
     values: &[&["injection"]],
     range: 5..=5,
 };
 
-static WORD_INEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEG_CHILDREN),
+static WORD_INEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rate"),
         dictgen::InsensitiveStr::Ascii("rated"),
@@ -121722,12 +121722,12 @@ pub static WORD_INEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_INEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEF_CHILDREN),
+static WORD_INEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fciency"),
         dictgen::InsensitiveStr::Ascii("fcient"),
@@ -121775,23 +121775,23 @@ pub static WORD_INEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_INEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INEA_CHILDREN),
+static WORD_INEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("risation")],
     values: &[&["linearisation"]],
     range: 8..=8,
 };
 
-static WORD_IND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IND_CHILDREN),
+static WORD_IND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IND_CHILDREN),
     value: None,
 };
 
-static WORD_IND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IND_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INDA_NODE),
     None,
     Some(&WORD_INDC_NODE),
@@ -121820,23 +121820,23 @@ static WORD_IND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INDX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDX_CHILDREN),
+static WORD_INDX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDX_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["indexes"]],
     range: 2..=2,
 };
 
-static WORD_INDV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDV_CHILDREN),
+static WORD_INDV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idual"),
         dictgen::InsensitiveStr::Ascii("iduals"),
@@ -121845,12 +121845,12 @@ pub static WORD_INDV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_INDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDU_CHILDREN),
+static WORD_INDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gle"),
         dictgen::InsensitiveStr::Ascii("lgue"),
@@ -121904,23 +121904,23 @@ pub static WORD_INDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_INDS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDS_CHILDREN),
+static WORD_INDS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utry")],
     values: &[&["industry"]],
     range: 4..=4,
 };
 
-static WORD_INDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDR_CHILDREN),
+static WORD_INDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("oduction"),
@@ -121930,12 +121930,12 @@ pub static WORD_INDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_INDP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDP_CHILDREN),
+static WORD_INDP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("endence"),
         dictgen::InsensitiveStr::Ascii("endent"),
@@ -121945,12 +121945,12 @@ pub static WORD_INDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_INDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDO_CHILDREN),
+static WORD_INDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crtinated"),
         dictgen::InsensitiveStr::Ascii("crtination"),
@@ -121998,12 +121998,12 @@ pub static WORD_INDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_INDL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDL_CHILDREN),
+static WORD_INDL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uces"),
         dictgen::InsensitiveStr::Ascii("uge"),
@@ -122012,12 +122012,12 @@ pub static WORD_INDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_INDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INDI_CHILDREN),
+static WORD_INDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INDI_CHILDREN),
     value: None,
 };
 
-static WORD_INDI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INDI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INDIA_NODE),
     None,
     Some(&WORD_INDIC_NODE),
@@ -122046,23 +122046,23 @@ static WORD_INDI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_INDIZ_NODE),
 ];
 
-static WORD_INDIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIZ_CHILDREN),
+static WORD_INDIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["indices"]],
     range: 3..=3,
 };
 
-static WORD_INDIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIV_CHILDREN),
+static WORD_INDIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dual"),
         dictgen::InsensitiveStr::Ascii("dually"),
@@ -122170,12 +122170,12 @@ pub static WORD_INDIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INDIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIS_CHILDREN),
+static WORD_INDIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crimnate"),
         dictgen::InsensitiveStr::Ascii("ious"),
@@ -122207,12 +122207,12 @@ pub static WORD_INDIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_INDIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIR_CHILDREN),
+static WORD_INDIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eclty"),
         dictgen::InsensitiveStr::Ascii("ectely"),
@@ -122228,12 +122228,12 @@ pub static WORD_INDIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INDIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIQ_CHILDREN),
+static WORD_INDIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uate"),
         dictgen::InsensitiveStr::Ascii("uates"),
@@ -122242,12 +122242,12 @@ pub static WORD_INDIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_INDIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIP_CHILDREN),
+static WORD_INDIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("endence"),
         dictgen::InsensitiveStr::Ascii("endent"),
@@ -122257,12 +122257,12 @@ pub static WORD_INDIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_INDIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIM_CHILDREN),
+static WORD_INDIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idating"),
         dictgen::InsensitiveStr::Ascii("idation"),
@@ -122271,23 +122271,23 @@ pub static WORD_INDIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_INDIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIK_CHILDREN),
+static WORD_INDIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["indication"]],
     range: 5..=5,
 };
 
-static WORD_INDIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIG_CHILDREN),
+static WORD_INDIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eneous"),
         dictgen::InsensitiveStr::Ascii("enious"),
@@ -122311,12 +122311,12 @@ pub static WORD_INDIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INDIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIF_CHILDREN),
+static WORD_INDIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ferance"),
         dictgen::InsensitiveStr::Ascii("ferant"),
@@ -122336,12 +122336,12 @@ pub static WORD_INDIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INDIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIE_CHILDREN),
+static WORD_INDIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -122350,23 +122350,23 @@ pub static WORD_INDIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_INDID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDID_CHILDREN),
+static WORD_INDID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDID_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["inside", "indeed"]],
     range: 1..=1,
 };
 
-static WORD_INDIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIC_CHILDREN),
+static WORD_INDIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aite"),
         dictgen::InsensitiveStr::Ascii("aste"),
@@ -122444,12 +122444,12 @@ pub static WORD_INDIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INDIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDIA_CHILDREN),
+static WORD_INDIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("cte"),
@@ -122487,12 +122487,12 @@ pub static WORD_INDIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_INDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INDE_CHILDREN),
+static WORD_INDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INDE_CHILDREN),
     value: None,
 };
 
-static WORD_INDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INDE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_INDEC_NODE),
@@ -122521,12 +122521,12 @@ static WORD_INDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INDEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEX_CHILDREN),
+static WORD_INDEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ig"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -122536,12 +122536,12 @@ pub static WORD_INDEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_INDEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEV_CHILDREN),
+static WORD_INDEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -122559,12 +122559,12 @@ pub static WORD_INDEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INDET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDET_CHILDREN),
+static WORD_INDET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDET_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifiable"),
         dictgen::InsensitiveStr::Ascii("ification"),
@@ -122573,12 +122573,12 @@ pub static WORD_INDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_INDES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDES_CHILDREN),
+static WORD_INDES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDES_CHILDREN),
     value: Some(&["index"]),
 };
 
-pub static WORD_INDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("criminent"),
         dictgen::InsensitiveStr::Ascii("pensable"),
@@ -122600,12 +122600,12 @@ pub static WORD_INDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_INDER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDER_CHILDREN),
+static WORD_INDER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDER_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ictly"),
@@ -122615,12 +122615,12 @@ pub static WORD_INDER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_INDEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INDEP_CHILDREN),
+static WORD_INDEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INDEP_CHILDREN),
     value: None,
 };
 
-static WORD_INDEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INDEP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INDEPA_NODE),
     None,
     None,
@@ -122649,12 +122649,12 @@ static WORD_INDEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INDEPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEPE_CHILDREN),
+static WORD_INDEPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dantly"),
         dictgen::InsensitiveStr::Ascii("dence"),
@@ -122764,12 +122764,12 @@ pub static WORD_INDEPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_INDEPD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEPD_CHILDREN),
+static WORD_INDEPD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEPD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEPD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("encente"),
@@ -122813,23 +122813,23 @@ pub static WORD_INDEPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_INDEPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEPA_CHILDREN),
+static WORD_INDEPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ndance")],
     values: &[&["independence"]],
     range: 6..=6,
 };
 
-static WORD_INDEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEN_CHILDREN),
+static WORD_INDEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dation"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -122881,34 +122881,34 @@ pub static WORD_INDEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_INDEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEM_CHILDREN),
+static WORD_INDEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("potent")],
     values: &[&["idempotent"]],
     range: 6..=6,
 };
 
-static WORD_INDEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEG_CHILDREN),
+static WORD_INDEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inous")],
     values: &[&["indigenous"]],
     range: 5..=5,
 };
 
-static WORD_INDEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEF_CHILDREN),
+static WORD_INDEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enite"),
         dictgen::InsensitiveStr::Ascii("inate"),
@@ -122952,23 +122952,23 @@ pub static WORD_INDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_INDED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDED_CHILDREN),
+static WORD_INDED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDED_CHILDREN),
     value: Some(&["indeed", "index"]),
 };
 
-pub static WORD_INDED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_INDEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDEC_CHILDREN),
+static WORD_INDEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -122979,12 +122979,12 @@ pub static WORD_INDEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_INDD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDD_CHILDREN),
+static WORD_INDD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ex"),
         dictgen::InsensitiveStr::Ascii("ividual"),
@@ -123000,12 +123000,12 @@ pub static WORD_INDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDC_CHILDREN),
+static WORD_INDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -123014,12 +123014,12 @@ pub static WORD_INDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_INDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INDA_CHILDREN),
+static WORD_INDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("equate"),
         dictgen::InsensitiveStr::Ascii("ins"),
@@ -123035,12 +123035,12 @@ pub static WORD_INDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INC_CHILDREN),
+static WORD_INC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INC_CHILDREN),
     value: None,
 };
 
-static WORD_INC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INCA_NODE),
     None,
     None,
@@ -123069,23 +123069,23 @@ static WORD_INC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCV_CHILDREN),
+static WORD_INCV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("alid")],
     values: &[&["invalid"]],
     range: 4..=4,
 };
 
-static WORD_INCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCU_CHILDREN),
+static WORD_INCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -123123,12 +123123,12 @@ pub static WORD_INCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_INCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCT_CHILDREN),
+static WORD_INCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("roduce"),
@@ -123138,12 +123138,12 @@ pub static WORD_INCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_INCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCR_CHILDREN),
+static WORD_INCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCR_CHILDREN),
     value: None,
 };
 
-static WORD_INCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INCRA_NODE),
     None,
     None,
@@ -123172,23 +123172,23 @@ static WORD_INCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRO_CHILDREN),
+static WORD_INCRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mpehensible")],
     values: &[&["incomprehensible"]],
     range: 11..=11,
 };
 
-static WORD_INCRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRM_CHILDREN),
+static WORD_INCRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enet"),
         dictgen::InsensitiveStr::Ascii("enetd"),
@@ -123214,12 +123214,12 @@ pub static WORD_INCRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_INCRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRI_CHILDREN),
+static WORD_INCRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mental"),
         dictgen::InsensitiveStr::Ascii("ments"),
@@ -123228,23 +123228,23 @@ pub static WORD_INCRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_INCRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRF_CHILDREN),
+static WORD_INCRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("emental")],
     values: &[&["incremental"]],
     range: 7..=7,
 };
 
-static WORD_INCRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRE_CHILDREN),
+static WORD_INCRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adible"),
         dictgen::InsensitiveStr::Ascii("ading"),
@@ -123350,12 +123350,12 @@ pub static WORD_INCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_INCRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCRA_CHILDREN),
+static WORD_INCRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mental"),
         dictgen::InsensitiveStr::Ascii("mentally"),
@@ -123371,23 +123371,23 @@ pub static WORD_INCRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_INCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCP_CHILDREN),
+static WORD_INCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etion")],
     values: &[&["inception"]],
     range: 5..=5,
 };
 
-static WORD_INCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCO_CHILDREN),
+static WORD_INCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCO_CHILDREN),
     value: None,
 };
 
-static WORD_INCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -123416,12 +123416,12 @@ static WORD_INCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOV_CHILDREN),
+static WORD_INCOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enience"),
         dictgen::InsensitiveStr::Ascii("ience"),
@@ -123430,12 +123430,12 @@ pub static WORD_INCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INCOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOS_CHILDREN),
+static WORD_INCOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("istencies"),
         dictgen::InsensitiveStr::Ascii("istency"),
@@ -123451,12 +123451,12 @@ pub static WORD_INCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_INCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOR_CHILDREN),
+static WORD_INCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ectly"),
@@ -123532,12 +123532,12 @@ pub static WORD_INCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_INCOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOP_CHILDREN),
+static WORD_INCOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erate"),
         dictgen::InsensitiveStr::Ascii("erated"),
@@ -123569,23 +123569,23 @@ pub static WORD_INCOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_INCOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOO_CHILDREN),
+static WORD_INCOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("perates")],
     values: &[&["incorporates"]],
     range: 7..=7,
 };
 
-static WORD_INCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCON_CHILDREN),
+static WORD_INCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCON_CHILDREN),
     value: None,
 };
 
-static WORD_INCON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_INCONC_NODE),
@@ -123614,12 +123614,12 @@ static WORD_INCON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCONV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONV_CHILDREN),
+static WORD_INCONV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eience"),
         dictgen::InsensitiveStr::Ascii("eince"),
@@ -123697,23 +123697,23 @@ pub static WORD_INCONV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_INCONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONT_CHILDREN),
+static WORD_INCONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rollably")],
     values: &[&["uncontrollably"]],
     range: 8..=8,
 };
 
-static WORD_INCONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONS_CHILDREN),
+static WORD_INCONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONS_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciously"),
         dictgen::InsensitiveStr::Ascii("ecuential"),
@@ -123803,34 +123803,34 @@ pub static WORD_INCONS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_INCONP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONP_CHILDREN),
+static WORD_INCONP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rehensible")],
     values: &[&["incomprehensible"]],
     range: 10..=10,
 };
 
-static WORD_INCONL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONL_CHILDREN),
+static WORD_INCONL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("usive")],
     values: &[&["inconclusive"]],
     range: 5..=5,
 };
 
-static WORD_INCONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONI_CHILDREN),
+static WORD_INCONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sistent"),
         dictgen::InsensitiveStr::Ascii("stencies"),
@@ -123839,23 +123839,23 @@ pub static WORD_INCONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=8,
 };
 
-static WORD_INCONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONG_CHILDREN),
+static WORD_INCONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ito")],
     values: &[&["incognito"]],
     range: 3..=3,
 };
 
-static WORD_INCONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONF_CHILDREN),
+static WORD_INCONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ortable"),
@@ -123864,12 +123864,12 @@ pub static WORD_INCONF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_INCOND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOND_CHILDREN),
+static WORD_INCOND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOND_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itional"),
         dictgen::InsensitiveStr::Ascii("itionally"),
@@ -123878,12 +123878,12 @@ pub static WORD_INCOND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=9,
 };
 
-static WORD_INCONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCONC_CHILDREN),
+static WORD_INCONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCONC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCONC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("equential"),
         dictgen::InsensitiveStr::Ascii("iderate"),
@@ -123901,12 +123901,12 @@ pub static WORD_INCONC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=9,
 };
 
-static WORD_INCOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCOM_CHILDREN),
+static WORD_INCOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCOM_CHILDREN),
     value: None,
 };
 
-static WORD_INCOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCOM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INCOMA_NODE),
     Some(&WORD_INCOMB_NODE),
     None,
@@ -123935,12 +123935,12 @@ static WORD_INCOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCOMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INCOMP_CHILDREN),
+static WORD_INCOMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INCOMP_CHILDREN),
     value: None,
 };
 
-static WORD_INCOMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INCOMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_INCOMPA_NODE),
     None,
     None,
@@ -123969,12 +123969,12 @@ static WORD_INCOMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INCOMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPT_CHILDREN),
+static WORD_INCOMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("etent"),
@@ -123984,12 +123984,12 @@ pub static WORD_INCOMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=5,
 };
 
-static WORD_INCOMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPR_CHILDREN),
+static WORD_INCOMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ehencible"),
         dictgen::InsensitiveStr::Ascii("ehendible"),
@@ -124013,23 +124013,23 @@ pub static WORD_INCOMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 8..=9,
 };
 
-static WORD_INCOMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPO_CHILDREN),
+static WORD_INCOMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tent")],
     values: &[&["incompetent"]],
     range: 4..=4,
 };
 
-static WORD_INCOMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPL_CHILDREN),
+static WORD_INCOMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eate"),
         dictgen::InsensitiveStr::Ascii("eete"),
@@ -124039,12 +124039,12 @@ pub static WORD_INCOMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_INCOMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPI_CHILDREN),
+static WORD_INCOMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("table"),
@@ -124054,12 +124054,12 @@ pub static WORD_INCOMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=5,
 };
 
-static WORD_INCOMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPE_CHILDREN),
+static WORD_INCOMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tance"),
         dictgen::InsensitiveStr::Ascii("tant"),
@@ -124077,12 +124077,12 @@ pub static WORD_INCOMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_INCOMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMPA_CHILDREN),
+static WORD_INCOMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -124178,23 +124178,23 @@ pub static WORD_INCOMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=10,
 };
 
-static WORD_INCOMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMN_CHILDREN),
+static WORD_INCOMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["incoming"]],
     range: 1..=1,
 };
 
-static WORD_INCOMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMM_CHILDREN),
+static WORD_INCOMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("plete"),
@@ -124203,12 +124203,12 @@ pub static WORD_INCOMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_INCOMF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMF_CHILDREN),
+static WORD_INCOMF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMF_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ortable"),
@@ -124222,12 +124222,12 @@ pub static WORD_INCOMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_INCOMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMB_CHILDREN),
+static WORD_INCOMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atibilities"),
         dictgen::InsensitiveStr::Ascii("atibility"),
@@ -124236,12 +124236,12 @@ pub static WORD_INCOMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 9..=11,
 };
 
-static WORD_INCOMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOMA_CHILDREN),
+static WORD_INCOMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("patibility"),
         dictgen::InsensitiveStr::Ascii("patible"),
@@ -124263,12 +124263,12 @@ pub static WORD_INCOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=11,
 };
 
-static WORD_INCOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOH_CHILDREN),
+static WORD_INCOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erance"),
         dictgen::InsensitiveStr::Ascii("erancy"),
@@ -124288,12 +124288,12 @@ pub static WORD_INCOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_INCOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCOG_CHILDREN),
+static WORD_INCOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("into"),
         dictgen::InsensitiveStr::Ascii("nitio"),
@@ -124303,23 +124303,23 @@ pub static WORD_INCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_INCM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCM_CHILDREN),
+static WORD_INCM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCM_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rement")],
     values: &[&["increment"]],
     range: 6..=6,
 };
 
-static WORD_INCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCL_CHILDREN),
+static WORD_INCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anation"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -124415,12 +124415,12 @@ pub static WORD_INCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_INCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCI_CHILDREN),
+static WORD_INCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dencies"),
         dictgen::InsensitiveStr::Ascii("dentaly"),
@@ -124444,34 +124444,34 @@ pub static WORD_INCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCH_CHILDREN),
+static WORD_INCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oerent")],
     values: &[&["incoherent"]],
     range: 6..=6,
 };
 
-static WORD_INCG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCG_CHILDREN),
+static WORD_INCG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onito")],
     values: &[&["incognito"]],
     range: 5..=5,
 };
 
-static WORD_INCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCE_CHILDREN),
+static WORD_INCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dent"),
         dictgen::InsensitiveStr::Ascii("dentally"),
@@ -124517,12 +124517,12 @@ pub static WORD_INCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_INCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INCA_CHILDREN),
+static WORD_INCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_INCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lid"),
         dictgen::InsensitiveStr::Ascii("rantion"),
@@ -124560,12 +124560,12 @@ pub static WORD_INCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INB_CHILDREN),
+static WORD_INB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alance"),
         dictgen::InsensitiveStr::Ascii("alanced"),
@@ -124623,12 +124623,12 @@ pub static WORD_INB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_INA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_INA_CHILDREN),
+static WORD_INA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_INA_CHILDREN),
     value: None,
 };
 
-static WORD_INA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_INA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_INAB_NODE),
     Some(&WORD_INAC_NODE),
@@ -124657,12 +124657,12 @@ static WORD_INA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_INAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAV_CHILDREN),
+static WORD_INAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lid"),
         dictgen::InsensitiveStr::Ascii("lis"),
@@ -124671,23 +124671,23 @@ pub static WORD_INAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_INAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAU_CHILDREN),
+static WORD_INAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gures")],
     values: &[&["inaugurates"]],
     range: 5..=5,
 };
 
-static WORD_INAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAT_CHILDREN),
+static WORD_INAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ruction"),
@@ -124697,12 +124697,12 @@ pub static WORD_INAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_INAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAP_CHILDREN),
+static WORD_INAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("porpriate"),
         dictgen::InsensitiveStr::Ascii("porpriately"),
@@ -124746,45 +124746,45 @@ pub static WORD_INAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=12,
 };
 
-static WORD_INAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAL_CHILDREN),
+static WORD_INAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("id")],
     values: &[&["invalid"]],
     range: 2..=2,
 };
 
-static WORD_INAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAK_CHILDREN),
+static WORD_INAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tively")],
     values: &[&["inactively"]],
     range: 6..=6,
 };
 
-static WORD_INAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAH_CHILDREN),
+static WORD_INAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bitants")],
     values: &[&["inhabitants"]],
     range: 7..=7,
 };
 
-static WORD_INAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAG_CHILDREN),
+static WORD_INAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("urated"),
         dictgen::InsensitiveStr::Ascii("uration"),
@@ -124793,12 +124793,12 @@ pub static WORD_INAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_INAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAD_CHILDREN),
+static WORD_INAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aquate"),
         dictgen::InsensitiveStr::Ascii("aquete"),
@@ -124842,12 +124842,12 @@ pub static WORD_INAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_INAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAC_CHILDREN),
+static WORD_INAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccessible"),
         dictgen::InsensitiveStr::Ascii("cesible"),
@@ -124901,12 +124901,12 @@ pub static WORD_INAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_INAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_INAB_CHILDREN),
+static WORD_INAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_INAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_INAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_INAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -124924,12 +124924,12 @@ pub static WORD_INAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_IM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IM_CHILDREN),
+static WORD_IM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IM_CHILDREN),
     value: None,
 };
 
-static WORD_IM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMA_NODE),
     Some(&WORD_IMB_NODE),
     Some(&WORD_IMC_NODE),
@@ -124958,12 +124958,12 @@ static WORD_IM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMT_CHILDREN),
+static WORD_IMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imidating"),
         dictgen::InsensitiveStr::Ascii("imidation"),
@@ -124972,23 +124972,23 @@ pub static WORD_IMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=9,
 };
 
-static WORD_IMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMS_CHILDREN),
+static WORD_IMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ensitive")],
     values: &[&["insensitive"]],
     range: 8..=8,
 };
 
-static WORD_IMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMR_CHILDREN),
+static WORD_IMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ovement"),
         dictgen::InsensitiveStr::Ascii("pove"),
@@ -125012,12 +125012,12 @@ pub static WORD_IMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_IMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMP_CHILDREN),
+static WORD_IMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMP_CHILDREN),
     value: None,
 };
 
-static WORD_IMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPA_NODE),
     None,
     Some(&WORD_IMPC_NODE),
@@ -125046,12 +125046,12 @@ static WORD_IMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPU_CHILDREN),
+static WORD_IMPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("les"),
         dictgen::InsensitiveStr::Ascii("lisve"),
@@ -125087,12 +125087,12 @@ pub static WORD_IMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_IMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPR_CHILDREN),
+static WORD_IMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPR_CHILDREN),
     value: None,
 };
 
-static WORD_IMPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPRA_NODE),
     None,
     None,
@@ -125121,34 +125121,34 @@ static WORD_IMPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRT_CHILDREN),
+static WORD_IMPRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ant")],
     values: &[&["important"]],
     range: 3..=3,
 };
 
-static WORD_IMPRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRS_CHILDREN),
+static WORD_IMPRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ioned")],
     values: &[&["imprisoned"]],
     range: 5..=5,
 };
 
-static WORD_IMPRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRO_CHILDREN),
+static WORD_IMPRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("babe"),
         dictgen::InsensitiveStr::Ascii("babil"),
@@ -125278,12 +125278,12 @@ pub static WORD_IMPRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_IMPRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRI_CHILDREN),
+static WORD_IMPRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oned"),
         dictgen::InsensitiveStr::Ascii("sonent"),
@@ -125293,12 +125293,12 @@ pub static WORD_IMPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_IMPRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRE_CHILDREN),
+static WORD_IMPRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ative"),
         dictgen::InsensitiveStr::Ascii("fect"),
@@ -125338,12 +125338,12 @@ pub static WORD_IMPRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_IMPRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPRA_CHILDREN),
+static WORD_IMPRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctial"),
         dictgen::InsensitiveStr::Ascii("cticle"),
@@ -125352,12 +125352,12 @@ pub static WORD_IMPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_IMPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPP_CHILDREN),
+static WORD_IMPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lement"),
         dictgen::InsensitiveStr::Ascii("lementating"),
@@ -125373,12 +125373,12 @@ pub static WORD_IMPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=11,
 };
 
-static WORD_IMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPO_CHILDREN),
+static WORD_IMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPO_CHILDREN),
     value: None,
 };
 
-static WORD_IMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -125407,12 +125407,12 @@ static WORD_IMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOV_CHILDREN),
+static WORD_IMPOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -125438,12 +125438,12 @@ pub static WORD_IMPOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_IMPOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOT_CHILDREN),
+static WORD_IMPOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOT_CHILDREN),
     value: Some(&["import"]),
 };
 
-pub static WORD_IMPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -125457,12 +125457,12 @@ pub static WORD_IMPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_IMPOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOS_CHILDREN),
+static WORD_IMPOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ible"),
         dictgen::InsensitiveStr::Ascii("sable"),
@@ -125504,12 +125504,12 @@ pub static WORD_IMPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_IMPOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOR_CHILDREN),
+static WORD_IMPOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("atant"),
@@ -125609,23 +125609,23 @@ pub static WORD_IMPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_IMPOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPOL_CHILDREN),
+static WORD_IMPOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("de")],
     values: &[&["implode"]],
     range: 2..=2,
 };
 
-static WORD_IMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPL_CHILDREN),
+static WORD_IMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPL_CHILDREN),
     value: None,
 };
 
-static WORD_IMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPLA_NODE),
     None,
     Some(&WORD_IMPLC_NODE),
@@ -125654,12 +125654,12 @@ static WORD_IMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLU_CHILDREN),
+static WORD_IMPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -125669,12 +125669,12 @@ pub static WORD_IMPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_IMPLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLO_CHILDREN),
+static WORD_IMPLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("sed"),
@@ -125684,12 +125684,12 @@ pub static WORD_IMPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_IMPLM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLM_CHILDREN),
+static WORD_IMPLM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLM_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eentation"),
         dictgen::InsensitiveStr::Ascii("enet"),
@@ -125731,12 +125731,12 @@ pub static WORD_IMPLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_IMPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLI_CHILDREN),
+static WORD_IMPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cacion"),
         dictgen::InsensitiveStr::Ascii("cati"),
@@ -125810,12 +125810,12 @@ pub static WORD_IMPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_IMPLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPLE_CHILDREN),
+static WORD_IMPLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPLE_CHILDREN),
     value: None,
 };
 
-static WORD_IMPLE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPLE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_IMPLEC_NODE),
@@ -125844,12 +125844,12 @@ static WORD_IMPLE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLET_CHILDREN),
+static WORD_IMPLET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLET_CHILDREN),
     value: Some(&["implement"]),
 };
 
-pub static WORD_IMPLET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -125871,12 +125871,12 @@ pub static WORD_IMPLET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_IMPLEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEN_CHILDREN),
+static WORD_IMPLEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eted"),
         dictgen::InsensitiveStr::Ascii("ment"),
@@ -125904,12 +125904,12 @@ pub static WORD_IMPLEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_IMPLEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEM_CHILDREN),
+static WORD_IMPLEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPLEM_CHILDREN),
     value: None,
 };
 
-static WORD_IMPLEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPLEM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPLEMA_NODE),
     None,
     None,
@@ -125938,12 +125938,12 @@ static WORD_IMPLEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLEMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMT_CHILDREN),
+static WORD_IMPLEMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMT_CHILDREN),
     value: Some(&["implement"]),
 };
 
-pub static WORD_IMPLEMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -125965,12 +125965,12 @@ pub static WORD_IMPLEMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_IMPLEMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMN_CHILDREN),
+static WORD_IMPLEMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etation"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -125988,12 +125988,12 @@ pub static WORD_IMPLEMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_IMPLEME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEME_CHILDREN),
+static WORD_IMPLEME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPLEME_CHILDREN),
     value: None,
 };
 
-static WORD_IMPLEME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPLEME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -126022,12 +126022,12 @@ static WORD_IMPLEME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLEMET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMET_CHILDREN),
+static WORD_IMPLEMET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMET_CHILDREN),
     value: Some(&["implements", "implement"]),
 };
 
-pub static WORD_IMPLEMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -126049,12 +126049,12 @@ pub static WORD_IMPLEMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=6,
 };
 
-static WORD_IMPLEMEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEMEN_CHILDREN),
+static WORD_IMPLEMEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMPLEMEN_CHILDREN),
     value: Some(&["implement"]),
 };
 
-static WORD_IMPLEMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMPLEMEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMPLEMENA_NODE),
     None,
     Some(&WORD_IMPLEMENC_NODE),
@@ -126083,12 +126083,12 @@ static WORD_IMPLEMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMPLEMENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENT_CHILDREN),
+static WORD_IMPLEMENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("aciones"),
@@ -126190,34 +126190,34 @@ pub static WORD_IMPLEMENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=8,
 };
 
-static WORD_IMPLEMENR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENR_CHILDREN),
+static WORD_IMPLEMENR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["implement"]],
     range: 1..=1,
 };
 
-static WORD_IMPLEMENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENI_CHILDREN),
+static WORD_IMPLEMENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["implementing"]],
     range: 2..=2,
 };
 
-static WORD_IMPLEMENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENE_CHILDREN),
+static WORD_IMPLEMENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -126249,34 +126249,34 @@ pub static WORD_IMPLEMENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=7,
 };
 
-static WORD_IMPLEMEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMEND_CHILDREN),
+static WORD_IMPLEMEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMEND_CHILDREN),
     value: Some(&["implement"]),
 };
 
-pub static WORD_IMPLEMEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["implements"]],
     range: 1..=1,
 };
 
-static WORD_IMPLEMENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENC_CHILDREN),
+static WORD_IMPLEMENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["implemented"]],
     range: 3..=3,
 };
 
-static WORD_IMPLEMENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENA_CHILDREN),
+static WORD_IMPLEMENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tation"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -126294,12 +126294,12 @@ pub static WORD_IMPLEMENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 4..=6,
 };
 
-static WORD_IMPLEMEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMEM_CHILDREN),
+static WORD_IMPLEMEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emnt"),
         dictgen::InsensitiveStr::Ascii("emntation"),
@@ -126339,12 +126339,12 @@ pub static WORD_IMPLEMEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=9,
 };
 
-static WORD_IMPLEMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMA_CHILDREN),
+static WORD_IMPLEMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntation"),
         dictgen::InsensitiveStr::Ascii("taion"),
@@ -126358,23 +126358,23 @@ pub static WORD_IMPLEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=7,
 };
 
-static WORD_IMPLEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEI_CHILDREN),
+static WORD_IMPLEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ment")],
     values: &[&["implement"]],
     range: 4..=4,
 };
 
-static WORD_IMPLEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEE_CHILDREN),
+static WORD_IMPLEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mntation"),
         dictgen::InsensitiveStr::Ascii("mntations"),
@@ -126383,23 +126383,23 @@ pub static WORD_IMPLEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 8..=9,
 };
 
-static WORD_IMPLEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEC_CHILDREN),
+static WORD_IMPLEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ations")],
     values: &[&["implications"]],
     range: 6..=6,
 };
 
-static WORD_IMPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLC_CHILDREN),
+static WORD_IMPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("itly"),
@@ -126409,12 +126409,12 @@ pub static WORD_IMPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_IMPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPLA_CHILDREN),
+static WORD_IMPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -126450,12 +126450,12 @@ pub static WORD_IMPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_IMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPI_CHILDREN),
+static WORD_IMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("citly"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -126465,12 +126465,12 @@ pub static WORD_IMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_IMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPE_CHILDREN),
+static WORD_IMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ared"),
         dictgen::InsensitiveStr::Ascii("cabbly"),
@@ -126584,12 +126584,12 @@ pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_IMPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPC_CHILDREN),
+static WORD_IMPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -126600,12 +126600,12 @@ pub static WORD_IMPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_IMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMPA_CHILDREN),
+static WORD_IMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cte"),
         dictgen::InsensitiveStr::Ascii("ctes"),
@@ -126627,12 +126627,12 @@ pub static WORD_IMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_IMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMO_CHILDREN),
+static WORD_IMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilisation"),
         dictgen::InsensitiveStr::Ascii("licit"),
@@ -126662,23 +126662,23 @@ pub static WORD_IMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_IMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMN_CHILDREN),
+static WORD_IMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["image"]],
     range: 3..=3,
 };
 
-static WORD_IMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IMM_CHILDREN),
+static WORD_IMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IMM_CHILDREN),
     value: None,
 };
 
-static WORD_IMM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IMM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IMMA_NODE),
     Some(&WORD_IMMB_NODE),
     None,
@@ -126707,12 +126707,12 @@ static WORD_IMM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IMMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMU_CHILDREN),
+static WORD_IMMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("niy"),
         dictgen::InsensitiveStr::Ascii("nosupressant"),
@@ -126722,12 +126722,12 @@ pub static WORD_IMMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_IMMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMS_CHILDREN),
+static WORD_IMMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erive"),
         dictgen::InsensitiveStr::Ascii("ersive"),
@@ -126737,12 +126737,12 @@ pub static WORD_IMMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_IMMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMO_CHILDREN),
+static WORD_IMMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilie"),
         dictgen::InsensitiveStr::Ascii("bilien"),
@@ -126790,12 +126790,12 @@ pub static WORD_IMMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_IMMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMM_CHILDREN),
+static WORD_IMMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ediate"),
         dictgen::InsensitiveStr::Ascii("ediately"),
@@ -126804,12 +126804,12 @@ pub static WORD_IMMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_IMMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMI_CHILDREN),
+static WORD_IMMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dately"),
         dictgen::InsensitiveStr::Ascii("datly"),
@@ -126851,12 +126851,12 @@ pub static WORD_IMMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_IMME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMME_CHILDREN),
+static WORD_IMME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMME_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adiate"),
         dictgen::InsensitiveStr::Ascii("adiately"),
@@ -126940,23 +126940,23 @@ pub static WORD_IMME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_IMMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMB_CHILDREN),
+static WORD_IMMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oile")],
     values: &[&["immobile"]],
     range: 4..=4,
 };
 
-static WORD_IMMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMMA_CHILDREN),
+static WORD_IMMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("diate"),
         dictgen::InsensitiveStr::Ascii("diately"),
@@ -126980,12 +126980,12 @@ pub static WORD_IMMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_IML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IML_CHILDREN),
+static WORD_IML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IML_CHILDREN),
     value: None,
 };
 
-pub static WORD_IML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ementation"),
@@ -127021,12 +127021,12 @@ pub static WORD_IML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_IMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMI_CHILDREN),
+static WORD_IMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("diately"),
         dictgen::InsensitiveStr::Ascii("grant"),
@@ -127048,12 +127048,12 @@ pub static WORD_IMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_IMG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMG_CHILDREN),
+static WORD_IMG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMG_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -127063,12 +127063,12 @@ pub static WORD_IMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_IMF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMF_CHILDREN),
+static WORD_IMF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMF_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amus"),
         dictgen::InsensitiveStr::Ascii("ormation"),
@@ -127077,12 +127077,12 @@ pub static WORD_IMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_IME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IME_CHILDREN),
+static WORD_IME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IME_CHILDREN),
     value: None,
 };
 
-pub static WORD_IME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adiatly"),
         dictgen::InsensitiveStr::Ascii("datly"),
@@ -127106,12 +127106,12 @@ pub static WORD_IME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_IMC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMC_CHILDREN),
+static WORD_IMC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oming"),
         dictgen::InsensitiveStr::Ascii("omming"),
@@ -127133,12 +127133,12 @@ pub static WORD_IMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=13,
 };
 
-static WORD_IMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMB_CHILDREN),
+static WORD_IMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alanaced"),
         dictgen::InsensitiveStr::Ascii("alanaces"),
@@ -127180,12 +127180,12 @@ pub static WORD_IMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_IMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IMA_CHILDREN),
+static WORD_IMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blanced"),
         dictgen::InsensitiveStr::Ascii("blances"),
@@ -127243,12 +127243,12 @@ pub static WORD_IMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_IL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IL_CHILDREN),
+static WORD_IL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IL_CHILDREN),
     value: None,
 };
 
-static WORD_IL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ILA_NODE),
     None,
     None,
@@ -127277,12 +127277,12 @@ static WORD_IL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ILU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILU_CHILDREN),
+static WORD_ILU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("minate"),
         dictgen::InsensitiveStr::Ascii("minated"),
@@ -127306,45 +127306,45 @@ pub static WORD_ILU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_ILT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILT_CHILDREN),
+static WORD_ILT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erate")],
     values: &[&["literate"]],
     range: 5..=5,
 };
 
-static WORD_ILO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILO_CHILDREN),
+static WORD_ILO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gical")],
     values: &[&["illogical"]],
     range: 5..=5,
 };
 
-static WORD_ILN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILN_CHILDREN),
+static WORD_ILN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["illness"]],
     range: 3..=3,
 };
 
-static WORD_ILL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ILL_CHILDREN),
+static WORD_ILL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ILL_CHILDREN),
     value: None,
 };
 
-static WORD_ILL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ILL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -127373,12 +127373,12 @@ static WORD_ILL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ILLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLU_CHILDREN),
+static WORD_ILLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("manati"),
         dictgen::InsensitiveStr::Ascii("maniti"),
@@ -127476,12 +127476,12 @@ pub static WORD_ILLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_ILLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLS_CHILDREN),
+static WORD_ILLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uions"),
         dictgen::InsensitiveStr::Ascii("utration"),
@@ -127491,12 +127491,12 @@ pub static WORD_ILLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ILLN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLN_CHILDREN),
+static WORD_ILLN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esess"),
         dictgen::InsensitiveStr::Ascii("esss"),
@@ -127505,12 +127505,12 @@ pub static WORD_ILLN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_ILLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLI_CHILDREN),
+static WORD_ILLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egal"),
         dictgen::InsensitiveStr::Ascii("gal"),
@@ -127550,23 +127550,23 @@ pub static WORD_ILLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ILLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLG_CHILDREN),
+static WORD_ILLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["illegal"]],
     range: 2..=2,
 };
 
-static WORD_ILLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILLE_CHILDREN),
+static WORD_ILLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gales"),
         dictgen::InsensitiveStr::Ascii("galest"),
@@ -127614,23 +127614,23 @@ pub static WORD_ILLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ILI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILI_CHILDREN),
+static WORD_ILI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gal")],
     values: &[&["illegal"]],
     range: 3..=3,
 };
 
-static WORD_ILE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILE_CHILDREN),
+static WORD_ILE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agle"),
         dictgen::InsensitiveStr::Ascii("gal"),
@@ -127641,23 +127641,23 @@ pub static WORD_ILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ILA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ILA_CHILDREN),
+static WORD_ILA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ILA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ILA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ILA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nd")],
     values: &[&["island"]],
     range: 2..=2,
 };
 
-static WORD_II_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_II_CHILDREN),
+static WORD_II_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_II_CHILDREN),
     value: None,
 };
 
-pub static WORD_II_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_II_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("mmune"),
@@ -127679,12 +127679,12 @@ pub static WORD_II_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_IH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IH_CHILDREN),
+static WORD_IH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IH_CHILDREN),
     value: None,
 };
 
-pub static WORD_IH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aca"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -127693,12 +127693,12 @@ pub static WORD_IH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_IG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IG_CHILDREN),
+static WORD_IG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IG_CHILDREN),
     value: None,
 };
 
-static WORD_IG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -127727,12 +127727,12 @@ static WORD_IG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_IGZ_NODE),
 ];
 
-static WORD_IGZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IGZ_CHILDREN),
+static WORD_IGZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IGZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_IGZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IGZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("orted"),
@@ -127750,23 +127750,23 @@ pub static WORD_IGZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_IGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IGR_CHILDREN),
+static WORD_IGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_IGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nore")],
     values: &[&["ignore"]],
     range: 4..=4,
 };
 
-static WORD_IGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IGO_CHILDREN),
+static WORD_IGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IGO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IGO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ned"),
         dictgen::InsensitiveStr::Ascii("norando"),
@@ -127792,12 +127792,12 @@ pub static WORD_IGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_IGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IGN_CHILDREN),
+static WORD_IGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_IGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ested"),
@@ -127927,12 +127927,12 @@ pub static WORD_IGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_IF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IF_CHILDREN),
+static WORD_IF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IF_CHILDREN),
     value: None,
 };
 
-pub static WORD_IF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("normation"),
@@ -127943,12 +127943,12 @@ pub static WORD_IF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_IE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IE_CHILDREN),
+static WORD_IE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IE_CHILDREN),
     value: None,
 };
 
-pub static WORD_IE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chart"),
         dictgen::InsensitiveStr::Ascii("rland"),
@@ -127958,12 +127958,12 @@ pub static WORD_IE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_ID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ID_CHILDREN),
+static WORD_ID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ID_CHILDREN),
     value: None,
 };
 
-static WORD_ID_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ID_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IDA_NODE),
     None,
     None,
@@ -127992,23 +127992,23 @@ static WORD_ID_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDO_CHILDREN),
+static WORD_IDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ns")],
     values: &[&["icons"]],
     range: 2..=2,
 };
 
-static WORD_IDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDI_CHILDREN),
+static WORD_IDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -128054,12 +128054,12 @@ pub static WORD_IDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_IDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IDE_CHILDREN),
+static WORD_IDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IDE_CHILDREN),
     value: None,
 };
 
-static WORD_IDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IDE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_IDEA_NODE),
     None,
     None,
@@ -128088,12 +128088,12 @@ static WORD_IDE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IDET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDET_CHILDREN),
+static WORD_IDET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDET_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ifier"),
         dictgen::InsensitiveStr::Ascii("ifiers"),
@@ -128109,23 +128109,23 @@ pub static WORD_IDET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_IDES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDES_CHILDREN),
+static WORD_IDES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDES_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("a")],
     values: &[&["ideas", "ides"]],
     range: 1..=1,
 };
 
-static WORD_IDEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEP_CHILDREN),
+static WORD_IDEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("endent"),
         dictgen::InsensitiveStr::Ascii("endently"),
@@ -128135,12 +128135,12 @@ pub static WORD_IDEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_IDEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEO_CHILDREN),
+static WORD_IDEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lagies"),
         dictgen::InsensitiveStr::Ascii("ligically"),
@@ -128192,12 +128192,12 @@ pub static WORD_IDEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_IDEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_IDEN_CHILDREN),
+static WORD_IDEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_IDEN_CHILDREN),
     value: None,
 };
 
-static WORD_IDEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_IDEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -128226,12 +128226,12 @@ static WORD_IDEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_IDENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDENT_CHILDREN),
+static WORD_IDENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cal"),
@@ -128365,23 +128365,23 @@ pub static WORD_IDENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_IDENP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDENP_CHILDREN),
+static WORD_IDENP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDENP_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDENP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDENP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enendtly")],
     values: &[&["independently"]],
     range: 8..=8,
 };
 
-static WORD_IDENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDENI_CHILDREN),
+static WORD_IDENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fiable"),
         dictgen::InsensitiveStr::Ascii("fied"),
@@ -128411,12 +128411,12 @@ pub static WORD_IDENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_IDENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDENF_CHILDREN),
+static WORD_IDENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ier"),
@@ -128440,12 +128440,12 @@ pub static WORD_IDENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_IDEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEND_CHILDREN),
+static WORD_IDEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ified"),
         dictgen::InsensitiveStr::Ascii("ifier"),
@@ -128461,12 +128461,12 @@ pub static WORD_IDEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_IDEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEM_CHILDREN),
+static WORD_IDEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("opotent"),
         dictgen::InsensitiveStr::Ascii("pontent"),
@@ -128475,23 +128475,23 @@ pub static WORD_IDEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_IDEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEL_CHILDREN),
+static WORD_IDEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEL_CHILDREN),
     value: Some(&["idle"]),
 };
 
-pub static WORD_IDEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ogy")],
     values: &[&["ideology"]],
     range: 3..=3,
 };
 
-static WORD_IDEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEI_CHILDREN),
+static WORD_IDEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntify"),
         dictgen::InsensitiveStr::Ascii("tifed"),
@@ -128500,23 +128500,23 @@ pub static WORD_IDEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_IDEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEF_CHILDREN),
+static WORD_IDEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inite")],
     values: &[&["indefinite"]],
     range: 5..=5,
 };
 
-static WORD_IDEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDEA_CHILDREN),
+static WORD_IDEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("lisim"),
@@ -128544,12 +128544,12 @@ pub static WORD_IDEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_IDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IDA_CHILDREN),
+static WORD_IDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eidae"),
@@ -128559,12 +128559,12 @@ pub static WORD_IDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_IC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IC_CHILDREN),
+static WORD_IC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IC_CHILDREN),
     value: None,
 };
 
-pub static WORD_IC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eforg"),
         dictgen::InsensitiveStr::Ascii("efrong"),
@@ -128616,12 +128616,12 @@ pub static WORD_IC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_IB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IB_CHILDREN),
+static WORD_IB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IB_CHILDREN),
     value: None,
 };
 
-pub static WORD_IB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ject"),
         dictgen::InsensitiveStr::Ascii("jects"),
@@ -128641,12 +128641,12 @@ pub static WORD_IB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_IA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_IA_CHILDREN),
+static WORD_IA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_IA_CHILDREN),
     value: None,
 };
 
-pub static WORD_IA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_IA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mge"),
         dictgen::InsensitiveStr::Ascii("mges"),
@@ -128655,12 +128655,12 @@ pub static WORD_IA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_H_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_H_CHILDREN),
+static WORD_H_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_H_CHILDREN),
     value: None,
 };
 
-static WORD_H_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_H_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HA_NODE),
     None,
     None,
@@ -128689,12 +128689,12 @@ static WORD_H_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HY_CHILDREN),
+static WORD_HY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HY_CHILDREN),
     value: None,
 };
 
-static WORD_HY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HY_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_HYB_NODE),
     None,
@@ -128723,12 +128723,12 @@ static WORD_HY_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HYS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYS_CHILDREN),
+static WORD_HYS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tarical"),
         dictgen::InsensitiveStr::Ascii("tarically"),
@@ -128758,12 +128758,12 @@ pub static WORD_HYS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_HYR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYR_CHILDREN),
+static WORD_HYR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bids"),
         dictgen::InsensitiveStr::Ascii("dation"),
@@ -128774,12 +128774,12 @@ pub static WORD_HYR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_HYP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HYP_CHILDREN),
+static WORD_HYP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HYP_CHILDREN),
     value: None,
 };
 
-static WORD_HYP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HYP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HYPA_NODE),
     None,
     Some(&WORD_HYPC_NODE),
@@ -128808,12 +128808,12 @@ static WORD_HYP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HYPV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPV_CHILDREN),
+static WORD_HYPV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ervisor"),
         dictgen::InsensitiveStr::Ascii("ervisors"),
@@ -128829,12 +128829,12 @@ pub static WORD_HYPV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_HYPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPT_CHILDREN),
+static WORD_HYPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("othetical"),
@@ -128844,12 +128844,12 @@ pub static WORD_HYPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_HYPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPR_CHILDREN),
+static WORD_HYPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocisy"),
         dictgen::InsensitiveStr::Ascii("ocite"),
@@ -128859,12 +128859,12 @@ pub static WORD_HYPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_HYPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPO_CHILDREN),
+static WORD_HYPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("condriac"),
         dictgen::InsensitiveStr::Ascii("cracy"),
@@ -128964,34 +128964,34 @@ pub static WORD_HYPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_HYPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPN_CHILDREN),
+static WORD_HYPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oss")],
     values: &[&["hypnosis"]],
     range: 3..=3,
 };
 
-static WORD_HYPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPH_CHILDREN),
+static WORD_HYPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("otesis")],
     values: &[&["hypothesis"]],
     range: 6..=6,
 };
 
-static WORD_HYPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPE_CHILDREN),
+static WORD_HYPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nate"),
@@ -129057,23 +129057,23 @@ pub static WORD_HYPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_HYPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPC_CHILDREN),
+static WORD_HYPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orite")],
     values: &[&["hypocrite"]],
     range: 5..=5,
 };
 
-static WORD_HYPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYPA_CHILDREN),
+static WORD_HYPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thetical"),
         dictgen::InsensitiveStr::Ascii("thetically"),
@@ -129082,12 +129082,12 @@ pub static WORD_HYPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_HYO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYO_CHILDREN),
+static WORD_HYO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pcrite"),
         dictgen::InsensitiveStr::Ascii("pthetical"),
@@ -129097,12 +129097,12 @@ pub static WORD_HYO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=11,
 };
 
-static WORD_HYJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYJ_CHILDREN),
+static WORD_HYJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("acking"),
@@ -129111,12 +129111,12 @@ pub static WORD_HYJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_HYG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYG_CHILDREN),
+static WORD_HYG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eine"),
         dictgen::InsensitiveStr::Ascii("ene"),
@@ -129136,12 +129136,12 @@ pub static WORD_HYG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_HYE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYE_CHILDREN),
+static WORD_HYE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rarchy"),
         dictgen::InsensitiveStr::Ascii("rlink"),
@@ -129150,12 +129150,12 @@ pub static WORD_HYE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_HYD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYD_CHILDREN),
+static WORD_HYD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ogen"),
         dictgen::InsensitiveStr::Ascii("orgen"),
@@ -129187,12 +129187,12 @@ pub static WORD_HYD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_HYB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HYB_CHILDREN),
+static WORD_HYB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HYB_CHILDREN),
     value: None,
 };
 
-pub static WORD_HYB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HYB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernate"),
         dictgen::InsensitiveStr::Ascii("irds"),
@@ -129203,12 +129203,12 @@ pub static WORD_HYB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_HW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HW_CHILDREN),
+static WORD_HW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HW_CHILDREN),
     value: None,
 };
 
-pub static WORD_HW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("eaton"),
@@ -129228,12 +129228,12 @@ pub static WORD_HW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_HV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HV_CHILDREN),
+static WORD_HV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aing"),
@@ -129244,12 +129244,12 @@ pub static WORD_HV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_HU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HU_CHILDREN),
+static WORD_HU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HU_CHILDREN),
     value: None,
 };
 
-static WORD_HU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HUA_NODE),
     None,
     None,
@@ -129278,23 +129278,23 @@ static WORD_HU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUT_CHILDREN),
+static WORD_HUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nsman")],
     values: &[&["huntsman"]],
     range: 5..=5,
 };
 
-static WORD_HUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUS_CHILDREN),
+static WORD_HUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ban"),
         dictgen::InsensitiveStr::Ascii("bandos"),
@@ -129310,12 +129310,12 @@ pub static WORD_HUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_HUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUR_CHILDREN),
+static WORD_HUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dels"),
         dictgen::InsensitiveStr::Ascii("icane"),
@@ -129353,12 +129353,12 @@ pub static WORD_HUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_HUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUN_CHILDREN),
+static WORD_HUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agrian"),
         dictgen::InsensitiveStr::Ascii("agry"),
@@ -129398,12 +129398,12 @@ pub static WORD_HUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_HUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUM_CHILDREN),
+static WORD_HUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anaties"),
         dictgen::InsensitiveStr::Ascii("ands"),
@@ -129485,12 +129485,12 @@ pub static WORD_HUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_HUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUL_CHILDREN),
+static WORD_HUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("lucination"),
@@ -129500,23 +129500,23 @@ pub static WORD_HUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_HUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUE_CHILDREN),
+static WORD_HUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ristic")],
     values: &[&["heuristic"]],
     range: 6..=6,
 };
 
-static WORD_HUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HUA_CHILDREN),
+static WORD_HUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_HUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nted"),
         dictgen::InsensitiveStr::Ascii("nting"),
@@ -129525,12 +129525,12 @@ pub static WORD_HUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_HT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HT_CHILDREN),
+static WORD_HT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acccess"),
         dictgen::InsensitiveStr::Ascii("acces"),
@@ -129582,12 +129582,12 @@ pub static WORD_HT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HS_CHILDREN),
+static WORD_HS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("eldon"),
@@ -129615,12 +129615,12 @@ pub static WORD_HS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_HR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HR_CHILDREN),
+static WORD_HR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adware"),
         dictgen::InsensitiveStr::Ascii("adwares"),
@@ -129646,23 +129646,23 @@ pub static WORD_HR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_HP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HP_CHILDREN),
+static WORD_HP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["hope"]],
     range: 1..=1,
 };
 
-static WORD_HO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HO_CHILDREN),
+static WORD_HO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HO_CHILDREN),
     value: None,
 };
 
-static WORD_HO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -129691,12 +129691,12 @@ static WORD_HO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOW_CHILDREN),
+static WORD_HOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eever"),
         dictgen::InsensitiveStr::Ascii("erver"),
@@ -129718,12 +129718,12 @@ pub static WORD_HOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_HOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOV_CHILDREN),
+static WORD_HOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ever"),
         dictgen::InsensitiveStr::Ascii("ewer"),
@@ -129732,12 +129732,12 @@ pub static WORD_HOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_HOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOU_CHILDREN),
+static WORD_HOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("nour"),
@@ -129767,12 +129767,12 @@ pub static WORD_HOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_HOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOT_CHILDREN),
+static WORD_HOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hsot"),
         dictgen::InsensitiveStr::Ascii("izontal"),
@@ -129796,12 +129796,12 @@ pub static WORD_HOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOS_CHILDREN),
+static WORD_HOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ited"),
         dictgen::InsensitiveStr::Ascii("itlity"),
@@ -129863,12 +129863,12 @@ pub static WORD_HOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOR_CHILDREN),
+static WORD_HOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ader"),
         dictgen::InsensitiveStr::Ascii("ading"),
@@ -129968,12 +129968,12 @@ pub static WORD_HOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_HOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOP_CHILDREN),
+static WORD_HOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efull"),
         dictgen::InsensitiveStr::Ascii("efulle"),
@@ -130027,12 +130027,12 @@ pub static WORD_HOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_HOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOO_CHILDREN),
+static WORD_HOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ok"),
         dictgen::InsensitiveStr::Ascii("oks"),
@@ -130042,12 +130042,12 @@ pub static WORD_HOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_HON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HON_CHILDREN),
+static WORD_HON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HON_CHILDREN),
     value: None,
 };
 
-pub static WORD_HON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eslty"),
         dictgen::InsensitiveStr::Ascii("eymon"),
@@ -130067,12 +130067,12 @@ pub static WORD_HON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_HOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HOM_CHILDREN),
+static WORD_HOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HOM_CHILDREN),
     value: Some(&["home"]),
 };
 
-static WORD_HOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HOM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HOMA_NODE),
     None,
     None,
@@ -130101,12 +130101,12 @@ static WORD_HOM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HOMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOMO_CHILDREN),
+static WORD_HOMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egenous"),
         dictgen::InsensitiveStr::Ascii("epathy"),
@@ -130190,34 +130190,34 @@ pub static WORD_HOMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_HOMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOMN_CHILDREN),
+static WORD_HOMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iem")],
     values: &[&["hominem"]],
     range: 3..=3,
 };
 
-static WORD_HOML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOML_CHILDREN),
+static WORD_HOML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOML_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ess")],
     values: &[&["homeless"]],
     range: 3..=3,
 };
 
-static WORD_HOMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOMI_CHILDREN),
+static WORD_HOMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("neim"),
         dictgen::InsensitiveStr::Ascii("neum"),
@@ -130226,12 +130226,12 @@ pub static WORD_HOMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_HOME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOME_CHILDREN),
+static WORD_HOME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOME_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("comeing"),
         dictgen::InsensitiveStr::Ascii("comming"),
@@ -130287,23 +130287,23 @@ pub static WORD_HOME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_HOMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOMA_CHILDREN),
+static WORD_HOMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("page")],
     values: &[&["homepage"]],
     range: 4..=4,
 };
 
-static WORD_HOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOL_CHILDREN),
+static WORD_HOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("diay"),
         dictgen::InsensitiveStr::Ascii("diays"),
@@ -130331,12 +130331,12 @@ pub static WORD_HOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOK_CHILDREN),
+static WORD_HOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("pins"),
@@ -130345,12 +130345,12 @@ pub static WORD_HOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_HOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOI_CHILDREN),
+static WORD_HOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lday"),
         dictgen::InsensitiveStr::Ascii("ldays"),
@@ -130359,12 +130359,12 @@ pub static WORD_HOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_HOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOE_CHILDREN),
+static WORD_HOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ks"),
         dictgen::InsensitiveStr::Ascii("mopathy"),
@@ -130384,12 +130384,12 @@ pub static WORD_HOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HOD_CHILDREN),
+static WORD_HOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -130399,23 +130399,23 @@ pub static WORD_HOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_HN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HN_CHILDREN),
+static WORD_HN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("alder")],
     values: &[&["handler"]],
     range: 5..=5,
 };
 
-static WORD_HM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HM_CHILDREN),
+static WORD_HM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("di"),
         dictgen::InsensitiveStr::Ascii("tl"),
@@ -130424,34 +130424,34 @@ pub static WORD_HM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=2,
 };
 
-static WORD_HL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HL_CHILDREN),
+static WORD_HL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ep")],
     values: &[&["help"]],
     range: 2..=2,
 };
 
-static WORD_HJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HJ_CHILDREN),
+static WORD_HJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_HJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ave")],
     values: &[&["have"]],
     range: 3..=3,
 };
 
-static WORD_HI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HI_CHILDREN),
+static WORD_HI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HI_CHILDREN),
     value: None,
 };
 
-static WORD_HI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HIA_NODE),
     None,
     Some(&WORD_HIC_NODE),
@@ -130480,23 +130480,23 @@ static WORD_HI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIY_CHILDREN),
+static WORD_HIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("geine")],
     values: &[&["hygiene"]],
     range: 5..=5,
 };
 
-static WORD_HIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIT_CHILDREN),
+static WORD_HIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("boxers"),
         dictgen::InsensitiveStr::Ascii("boxs"),
@@ -130516,12 +130516,12 @@ pub static WORD_HIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_HIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIS_CHILDREN),
+static WORD_HIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("melf"),
         dictgen::InsensitiveStr::Ascii("ory"),
@@ -130623,12 +130623,12 @@ pub static WORD_HIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=15,
 };
 
-static WORD_HIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIR_CHILDREN),
+static WORD_HIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achy"),
         dictgen::InsensitiveStr::Ascii("archies"),
@@ -130650,12 +130650,12 @@ pub static WORD_HIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_HIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIP_CHILDREN),
+static WORD_HIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocritical"),
         dictgen::InsensitiveStr::Ascii("opotamus"),
@@ -130681,12 +130681,12 @@ pub static WORD_HIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_HIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIN_CHILDREN),
+static WORD_HIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("derance"),
         dictgen::InsensitiveStr::Ascii("derence"),
@@ -130714,12 +130714,12 @@ pub static WORD_HIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIM_CHILDREN),
+static WORD_HIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("selv"),
@@ -130729,12 +130729,12 @@ pub static WORD_HIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_HIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIL_CHILDREN),
+static WORD_HIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ight"),
         dictgen::InsensitiveStr::Ascii("ighted"),
@@ -130752,12 +130752,12 @@ pub static WORD_HIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_HIJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIJ_CHILDREN),
+static WORD_HIJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kack"),
         dictgen::InsensitiveStr::Ascii("kacked"),
@@ -130768,12 +130768,12 @@ pub static WORD_HIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_HIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIH_CHILDREN),
+static WORD_HIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("glight"),
@@ -130783,12 +130783,12 @@ pub static WORD_HIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIG_CHILDREN),
+static WORD_HIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eine"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -130908,12 +130908,12 @@ pub static WORD_HIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_HIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIE_CHILDREN),
+static WORD_HIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("archical"),
         dictgen::InsensitiveStr::Ascii("archies"),
@@ -130989,12 +130989,12 @@ pub static WORD_HIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_HID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HID_CHILDREN),
+static WORD_HID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HID_CHILDREN),
     value: None,
 };
 
-pub static WORD_HID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dden"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -131016,23 +131016,23 @@ pub static WORD_HID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_HIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIC_CHILDREN),
+static WORD_HIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["which"]],
     range: 1..=1,
 };
 
-static WORD_HIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HIA_CHILDREN),
+static WORD_HIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_HIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rchical"),
         dictgen::InsensitiveStr::Ascii("rchically"),
@@ -131042,12 +131042,12 @@ pub static WORD_HIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HH_CHILDREN),
+static WORD_HH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ader"),
         dictgen::InsensitiveStr::Ascii("ttp"),
@@ -131056,23 +131056,23 @@ pub static WORD_HH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_HG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HG_CHILDREN),
+static WORD_HG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["he"]],
     range: 1..=1,
 };
 
-static WORD_HE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HE_CHILDREN),
+static WORD_HE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HE_CHILDREN),
     value: None,
 };
 
-static WORD_HE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HEA_NODE),
     None,
     None,
@@ -131101,12 +131101,12 @@ static WORD_HE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEX_CHILDREN),
+static WORD_HEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adeciaml"),
         dictgen::InsensitiveStr::Ascii("adeimcal"),
@@ -131132,12 +131132,12 @@ pub static WORD_HEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEV_CHILDREN),
+static WORD_HEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eanly"),
@@ -131147,12 +131147,12 @@ pub static WORD_HEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_HEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEU_CHILDREN),
+static WORD_HEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ristc"),
         dictgen::InsensitiveStr::Ascii("ristcs"),
@@ -131168,12 +131168,12 @@ pub static WORD_HEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_HET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HET_CHILDREN),
+static WORD_HET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HET_CHILDREN),
     value: None,
 };
 
-pub static WORD_HET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eresexual"),
         dictgen::InsensitiveStr::Ascii("erosexal"),
@@ -131193,12 +131193,12 @@ pub static WORD_HET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=11,
 };
 
-static WORD_HES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HES_CHILDREN),
+static WORD_HES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HES_CHILDREN),
     value: None,
 };
 
-pub static WORD_HES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -131238,12 +131238,12 @@ pub static WORD_HES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_HER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HER_CHILDREN),
+static WORD_HER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HER_CHILDREN),
     value: None,
 };
 
-pub static WORD_HER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("archy"),
@@ -131325,12 +131325,12 @@ pub static WORD_HER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_HEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEP_CHILDREN),
+static WORD_HEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ler"),
@@ -131340,12 +131340,12 @@ pub static WORD_HEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_HEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEO_CHILDREN),
+static WORD_HEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rics"),
         dictgen::InsensitiveStr::Ascii("rine"),
@@ -131354,12 +131354,12 @@ pub static WORD_HEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_HEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEN_CHILDREN),
+static WORD_HEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("derence"),
@@ -131377,12 +131377,12 @@ pub static WORD_HEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEM_CHILDREN),
+static WORD_HEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icircles"),
         dictgen::InsensitiveStr::Ascii("ingwary"),
@@ -131430,12 +131430,12 @@ pub static WORD_HEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_HEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEL_CHILDREN),
+static WORD_HEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEL_CHILDREN),
     value: Some(&["help", "hell", "heal"]),
 };
 
-pub static WORD_HEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ath"),
         dictgen::InsensitiveStr::Ascii("athcare"),
@@ -131511,12 +131511,12 @@ pub static WORD_HEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_HEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEI_CHILDREN),
+static WORD_HEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("delburg"),
         dictgen::InsensitiveStr::Ascii("gest"),
@@ -131574,34 +131574,34 @@ pub static WORD_HEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_HEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEG_CHILDREN),
+static WORD_HEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dehog")],
     values: &[&["hedgehog"]],
     range: 5..=5,
 };
 
-static WORD_HEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEF_CHILDREN),
+static WORD_HEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["heifer"]],
     range: 2..=2,
 };
 
-static WORD_HED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HED_CHILDREN),
+static WORD_HED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HED_CHILDREN),
     value: None,
 };
 
-pub static WORD_HED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aer"),
         dictgen::InsensitiveStr::Ascii("aers"),
@@ -131625,12 +131625,12 @@ pub static WORD_HED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_HEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HEA_CHILDREN),
+static WORD_HEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HEA_CHILDREN),
     value: None,
 };
 
-static WORD_HEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HEA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_HEAC_NODE),
@@ -131659,12 +131659,12 @@ static WORD_HEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HEAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAV_CHILDREN),
+static WORD_HEAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ely"),
         dictgen::InsensitiveStr::Ascii("eny"),
@@ -131694,12 +131694,12 @@ pub static WORD_HEAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_HEAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAT_CHILDREN),
+static WORD_HEAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hern"),
         dictgen::InsensitiveStr::Ascii("hy"),
@@ -131710,23 +131710,23 @@ pub static WORD_HEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_HEAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAS_CHILDREN),
+static WORD_HEAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tink")],
     values: &[&["heatsink"]],
     range: 4..=4,
 };
 
-static WORD_HEAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAR_CHILDREN),
+static WORD_HEAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("beat"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -131760,12 +131760,12 @@ pub static WORD_HEAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_HEAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAP_CHILDREN),
+static WORD_HEAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dhone"),
         dictgen::InsensitiveStr::Ascii("dhones"),
@@ -131774,12 +131774,12 @@ pub static WORD_HEAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_HEAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAL_CHILDREN),
+static WORD_HEAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ither"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -131813,23 +131813,23 @@ pub static WORD_HEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_HEAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAE_CHILDREN),
+static WORD_HEAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["header"]],
     range: 1..=1,
 };
 
-static WORD_HEAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAD_CHILDREN),
+static WORD_HEAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achs"),
         dictgen::InsensitiveStr::Ascii("ahces"),
@@ -131893,23 +131893,23 @@ pub static WORD_HEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_HEAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HEAC_CHILDREN),
+static WORD_HEAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HEAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HEAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["heavy"]],
     range: 1..=1,
 };
 
-static WORD_HD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HD_CHILDREN),
+static WORD_HD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("insight"),
@@ -131918,12 +131918,12 @@ pub static WORD_HD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HA_CHILDREN),
+static WORD_HA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HA_CHILDREN),
     value: None,
 };
 
-static WORD_HA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_HAA_NODE),
     Some(&WORD_HAB_NODE),
     Some(&WORD_HAC_NODE),
@@ -131952,45 +131952,45 @@ static WORD_HA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_HAZ_NODE),
 ];
 
-static WORD_HAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAZ_CHILDREN),
+static WORD_HAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("zle")],
     values: &[&["hassle"]],
     range: 3..=3,
 };
 
-static WORD_HAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAY_CHILDREN),
+static WORD_HAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nus")],
     values: &[&["heinous"]],
     range: 3..=3,
 };
 
-static WORD_HAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAX_CHILDREN),
+static WORD_HAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAX_CHILDREN),
     value: Some(&["hex"]),
 };
 
-pub static WORD_HAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_HAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAV_CHILDREN),
+static WORD_HAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAV_CHILDREN),
     value: Some(&["have", "half"]),
 };
 
-pub static WORD_HAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ea"),
@@ -132024,12 +132024,12 @@ pub static WORD_HAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAU_CHILDREN),
+static WORD_HAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lted"),
         dictgen::InsensitiveStr::Ascii("ntig"),
@@ -132039,12 +132039,12 @@ pub static WORD_HAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_HAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAT_CHILDREN),
+static WORD_HAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chig"),
         dictgen::InsensitiveStr::Ascii("chign"),
@@ -132062,12 +132062,12 @@ pub static WORD_HAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_HAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAS_CHILDREN),
+static WORD_HAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("hi"),
@@ -132097,12 +132097,12 @@ pub static WORD_HAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_HAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAR_CHILDREN),
+static WORD_HAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ased"),
         dictgen::InsensitiveStr::Ascii("ases"),
@@ -132210,12 +132210,12 @@ pub static WORD_HAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_HAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAP_CHILDREN),
+static WORD_HAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("end"),
@@ -132301,12 +132301,12 @@ pub static WORD_HAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_HAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAO_CHILDREN),
+static WORD_HAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rder"),
         dictgen::InsensitiveStr::Ascii("rding"),
@@ -132315,12 +132315,12 @@ pub static WORD_HAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_HAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HAN_CHILDREN),
+static WORD_HAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HAN_CHILDREN),
     value: None,
 };
 
-static WORD_HAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -132349,23 +132349,23 @@ static WORD_HAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HANU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANU_CHILDREN),
+static WORD_HANU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANU_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["haunted"]],
     range: 3..=3,
 };
 
-static WORD_HANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANS_CHILDREN),
+static WORD_HANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hake"),
         dictgen::InsensitiveStr::Ascii("haked"),
@@ -132381,12 +132381,12 @@ pub static WORD_HANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_HANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANN_CHILDREN),
+static WORD_HANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bial"),
         dictgen::InsensitiveStr::Ascii("dle"),
@@ -132397,12 +132397,12 @@ pub static WORD_HANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_HANL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANL_CHILDREN),
+static WORD_HANL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -132432,12 +132432,12 @@ pub static WORD_HANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_HANK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANK_CHILDREN),
+static WORD_HANK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANK_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erchif"),
         dictgen::InsensitiveStr::Ascii("erchifs"),
@@ -132446,45 +132446,45 @@ pub static WORD_HANK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_HANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANI_CHILDREN),
+static WORD_HANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dcapped")],
     values: &[&["handicapped"]],
     range: 7..=7,
 };
 
-static WORD_HANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANG_CHILDREN),
+static WORD_HANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ig")],
     values: &[&["hanging"]],
     range: 2..=2,
 };
 
-static WORD_HANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANE_CHILDREN),
+static WORD_HANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANE_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["handle"]],
     range: 1..=1,
 };
 
-static WORD_HAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_HAND_CHILDREN),
+static WORD_HAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_HAND_CHILDREN),
     value: None,
 };
 
-static WORD_HAND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_HAND_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_HANDB_NODE),
     Some(&WORD_HANDC_NODE),
@@ -132513,23 +132513,23 @@ static WORD_HAND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_HANDY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDY_CHILDREN),
+static WORD_HANDY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDY_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("capped")],
     values: &[&["handicapped"]],
     range: 6..=6,
 };
 
-static WORD_HANDW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDW_CHILDREN),
+static WORD_HANDW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDW_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irting"),
         dictgen::InsensitiveStr::Ascii("riten"),
@@ -132545,12 +132545,12 @@ pub static WORD_HANDW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_HANDS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDS_CHILDREN),
+static WORD_HANDS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDS_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ake"),
         dictgen::InsensitiveStr::Ascii("hacke"),
@@ -132612,23 +132612,23 @@ pub static WORD_HANDS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_HANDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDR_CHILDREN),
+static WORD_HANDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("witing")],
     values: &[&["handwriting"]],
     range: 6..=6,
 };
 
-static WORD_HANDL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDL_CHILDREN),
+static WORD_HANDL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("are"),
@@ -132654,12 +132654,12 @@ pub static WORD_HANDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_HANDK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDK_CHILDREN),
+static WORD_HANDK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDK_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("erchif"),
@@ -132669,12 +132669,12 @@ pub static WORD_HANDK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_HANDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDI_CHILDREN),
+static WORD_HANDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cape"),
         dictgen::InsensitiveStr::Ascii("caped"),
@@ -132683,34 +132683,34 @@ pub static WORD_HANDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_HANDH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDH_CHILDREN),
+static WORD_HANDH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ake")],
     values: &[&["handshake"]],
     range: 3..=3,
 };
 
-static WORD_HANDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDF_CHILDREN),
+static WORD_HANDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ull")],
     values: &[&["handful"]],
     range: 3..=3,
 };
 
-static WORD_HANDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDE_CHILDREN),
+static WORD_HANDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDE_CHILDREN),
     value: Some(&["handle", "hand"]),
 };
 
-pub static WORD_HANDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dley"),
         dictgen::InsensitiveStr::Ascii("dlly"),
@@ -132748,12 +132748,12 @@ pub static WORD_HANDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_HANDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDC_CHILDREN),
+static WORD_HANDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uffes"),
         dictgen::InsensitiveStr::Ascii("ufs"),
@@ -132762,12 +132762,12 @@ pub static WORD_HANDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_HANDB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HANDB_CHILDREN),
+static WORD_HANDB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HANDB_CHILDREN),
     value: None,
 };
 
-pub static WORD_HANDB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HANDB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ok"),
         dictgen::InsensitiveStr::Ascii("oook"),
@@ -132776,12 +132776,12 @@ pub static WORD_HANDB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_HAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAM_CHILDREN),
+static WORD_HAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bergers"),
         dictgen::InsensitiveStr::Ascii("bruger"),
@@ -132825,12 +132825,12 @@ pub static WORD_HAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_HAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAL_CHILDREN),
+static WORD_HAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arious"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -132902,12 +132902,12 @@ pub static WORD_HAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_HAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAI_CHILDREN),
+static WORD_HAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfax"),
         dictgen::InsensitiveStr::Ascii("rcuit"),
@@ -132918,23 +132918,23 @@ pub static WORD_HAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_HAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAH_CHILDREN),
+static WORD_HAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ve")],
     values: &[&["have", "halve", "half"]],
     range: 2..=2,
 };
 
-static WORD_HAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAG_CHILDREN),
+static WORD_HAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("ases"),
@@ -132944,23 +132944,23 @@ pub static WORD_HAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_HAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAF_CHILDREN),
+static WORD_HAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ltime")],
     values: &[&["halftime"]],
     range: 5..=5,
 };
 
-static WORD_HAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAE_CHILDREN),
+static WORD_HAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAE_CHILDREN),
     value: Some(&["have"]),
 };
 
-pub static WORD_HAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("morrage"),
@@ -132976,12 +132976,12 @@ pub static WORD_HAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_HAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAD_CHILDREN),
+static WORD_HAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("ler"),
@@ -132999,12 +132999,12 @@ pub static WORD_HAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_HAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAC_CHILDREN),
+static WORD_HAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -133020,12 +133020,12 @@ pub static WORD_HAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_HAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAB_CHILDREN),
+static WORD_HAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_HAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeus"),
         dictgen::InsensitiveStr::Ascii("bit"),
@@ -133047,23 +133047,23 @@ pub static WORD_HAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_HAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_HAA_CHILDREN),
+static WORD_HAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_HAA_CHILDREN),
     value: Some(&["has"]),
 };
 
-pub static WORD_HAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_HAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ve")],
     values: &[&["have"]],
     range: 2..=2,
 };
 
-static WORD_G_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_G_CHILDREN),
+static WORD_G_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_G_CHILDREN),
     value: None,
 };
 
-static WORD_G_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_G_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GA_NODE),
     None,
     None,
@@ -133092,12 +133092,12 @@ static WORD_G_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_GZ_NODE),
 ];
 
-static WORD_GZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GZ_CHILDREN),
+static WORD_GZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_GZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iniflate"),
         dictgen::InsensitiveStr::Ascii("iped"),
@@ -133106,12 +133106,12 @@ pub static WORD_GZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_GY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GY_CHILDREN),
+static WORD_GY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GY_CHILDREN),
     value: None,
 };
 
-pub static WORD_GY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lph"),
         dictgen::InsensitiveStr::Ascii("manstics"),
@@ -133139,23 +133139,23 @@ pub static WORD_GY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_GW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GW_CHILDREN),
+static WORD_GW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GW_CHILDREN),
     value: None,
 };
 
-pub static WORD_GW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ava")],
     values: &[&["guava"]],
     range: 3..=3,
 };
 
-static WORD_GU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GU_CHILDREN),
+static WORD_GU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GU_CHILDREN),
     value: None,
 };
 
-static WORD_GU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GUA_NODE),
     Some(&WORD_GUB_NODE),
     None,
@@ -133184,12 +133184,12 @@ static WORD_GU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GUY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUY_CHILDREN),
+static WORD_GUY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUY_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ser"),
         dictgen::InsensitiveStr::Ascii("sers"),
@@ -133200,12 +133200,12 @@ pub static WORD_GUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_GUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUT_CHILDREN),
+static WORD_GUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iarist"),
         dictgen::InsensitiveStr::Ascii("iars"),
@@ -133216,12 +133216,12 @@ pub static WORD_GUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_GUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUR_CHILDREN),
+static WORD_GUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adian"),
         dictgen::InsensitiveStr::Ascii("adians"),
@@ -133249,12 +133249,12 @@ pub static WORD_GUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_GUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUN_CHILDREN),
+static WORD_GUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anine"),
         dictgen::InsensitiveStr::Ascii("atanamo"),
@@ -133284,12 +133284,12 @@ pub static WORD_GUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=12,
 };
 
-static WORD_GUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUL_CHILDREN),
+static WORD_GUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lbile"),
         dictgen::InsensitiveStr::Ascii("libe"),
@@ -133298,12 +133298,12 @@ pub static WORD_GUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_GUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUI_CHILDREN),
+static WORD_GUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deance"),
         dictgen::InsensitiveStr::Ascii("deded"),
@@ -133335,12 +133335,12 @@ pub static WORD_GUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_GUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUE_CHILDREN),
+static WORD_GUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rrila"),
         dictgen::InsensitiveStr::Ascii("rrilas"),
@@ -133362,34 +133362,34 @@ pub static WORD_GUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_GUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUD_CHILDREN),
+static WORD_GUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUD_CHILDREN),
     value: Some(&["good"]),
 };
 
-pub static WORD_GUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["guide", "good"]],
     range: 1..=1,
 };
 
-static WORD_GUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUB_CHILDREN),
+static WORD_GUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("natorial")],
     values: &[&["gubernatorial"]],
     range: 8..=8,
 };
 
-static WORD_GUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GUA_CHILDREN),
+static WORD_GUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GUA_CHILDREN),
     value: None,
 };
 
-static WORD_GUA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GUA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -133418,12 +133418,12 @@ static WORD_GUA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GUAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAT_CHILDREN),
+static WORD_GUAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amala"),
         dictgen::InsensitiveStr::Ascii("amalan"),
@@ -133432,12 +133432,12 @@ pub static WORD_GUAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_GUAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAS_CHILDREN),
+static WORD_GUAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAS_CHILDREN),
     value: Some(&["gauss"]),
 };
 
-pub static WORD_GUAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("sian"),
@@ -133446,12 +133446,12 @@ pub static WORD_GUAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_GUAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GUAR_CHILDREN),
+static WORD_GUAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GUAR_CHILDREN),
     value: None,
 };
 
-static WORD_GUAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GUAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GUARA_NODE),
     Some(&WORD_GUARB_NODE),
     None,
@@ -133480,12 +133480,12 @@ static WORD_GUAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GUARU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARU_CHILDREN),
+static WORD_GUARU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ante"),
         dictgen::InsensitiveStr::Ascii("anted"),
@@ -133529,23 +133529,23 @@ pub static WORD_GUARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_GUART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUART_CHILDREN),
+static WORD_GUART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUART_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eed")],
     values: &[&["guaranteed"]],
     range: 3..=3,
 };
 
-static WORD_GUARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARR_CHILDREN),
+static WORD_GUARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ante"),
         dictgen::InsensitiveStr::Ascii("anted"),
@@ -133603,12 +133603,12 @@ pub static WORD_GUARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_GUARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARN_CHILDREN),
+static WORD_GUARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ante"),
         dictgen::InsensitiveStr::Ascii("anted"),
@@ -133698,12 +133698,12 @@ pub static WORD_GUARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_GUARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARI_CHILDREN),
+static WORD_GUARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dan"),
         dictgen::InsensitiveStr::Ascii("dans"),
@@ -133712,23 +133712,23 @@ pub static WORD_GUARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_GUARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARG_CHILDREN),
+static WORD_GUARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["guarding"]],
     range: 3..=3,
 };
 
-static WORD_GUARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARE_CHILDREN),
+static WORD_GUARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -133810,12 +133810,12 @@ pub static WORD_GUARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_GUARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARD_CHILDREN),
+static WORD_GUARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ains"),
@@ -133837,23 +133837,23 @@ pub static WORD_GUARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_GUARB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARB_CHILDREN),
+static WORD_GUARB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["garbage"]],
     range: 3..=3,
 };
 
-static WORD_GUARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUARA_CHILDREN),
+static WORD_GUARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nte"),
         dictgen::InsensitiveStr::Ascii("nted"),
@@ -133881,12 +133881,12 @@ pub static WORD_GUARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_GUAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAN_CHILDREN),
+static WORD_GUAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atanmo"),
         dictgen::InsensitiveStr::Ascii("tamamo"),
@@ -133916,23 +133916,23 @@ pub static WORD_GUAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_GUAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAG_CHILDREN),
+static WORD_GUAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["gage"]],
     range: 1..=1,
 };
 
-static WORD_GUAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GUAD_CHILDREN),
+static WORD_GUAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GUAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GUAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GUAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uloupe"),
         dictgen::InsensitiveStr::Ascii("ulupe"),
@@ -133941,23 +133941,23 @@ pub static WORD_GUAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_GT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GT_CHILDREN),
+static WORD_GT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("he")],
     values: &[&["the"]],
     range: 2..=2,
 };
 
-static WORD_GR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GR_CHILDREN),
+static WORD_GR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GR_CHILDREN),
     value: None,
 };
 
-static WORD_GR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GRA_NODE),
     Some(&WORD_GRB_NODE),
     None,
@@ -133986,23 +133986,23 @@ static WORD_GR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRW_CHILDREN),
+static WORD_GRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("o")],
     values: &[&["grow"]],
     range: 1..=1,
 };
 
-static WORD_GRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRU_CHILDREN),
+static WORD_GRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("op"),
         dictgen::InsensitiveStr::Ascii("opd"),
@@ -134026,23 +134026,23 @@ pub static WORD_GRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_GRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRR_CHILDREN),
+static WORD_GRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("anted")],
     values: &[&["granted"]],
     range: 5..=5,
 };
 
-static WORD_GRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRP_CHILDREN),
+static WORD_GRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ah"),
         dictgen::InsensitiveStr::Ascii("ahic"),
@@ -134062,12 +134062,12 @@ pub static WORD_GRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_GRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRO_CHILDREN),
+static WORD_GRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bal"),
         dictgen::InsensitiveStr::Ascii("bally"),
@@ -134135,12 +134135,12 @@ pub static WORD_GRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_GRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRI_CHILDREN),
+static WORD_GRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("affe"),
         dictgen::InsensitiveStr::Ascii("dles"),
@@ -134172,12 +134172,12 @@ pub static WORD_GRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_GRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRE_CHILDREN),
+static WORD_GRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ande"),
@@ -134235,23 +134235,23 @@ pub static WORD_GRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_GRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRB_CHILDREN),
+static WORD_GRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ber")],
     values: &[&["grabber"]],
     range: 3..=3,
 };
 
-static WORD_GRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GRA_CHILDREN),
+static WORD_GRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GRA_CHILDREN),
     value: None,
 };
 
-static WORD_GRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_GRAB_NODE),
     Some(&WORD_GRAC_NODE),
@@ -134280,12 +134280,12 @@ static WORD_GRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAV_CHILDREN),
+static WORD_GRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itacional"),
         dictgen::InsensitiveStr::Ascii("itaitonal"),
@@ -134305,12 +134305,12 @@ pub static WORD_GRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=10,
 };
 
-static WORD_GRAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAU_CHILDREN),
+static WORD_GRAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dally"),
         dictgen::InsensitiveStr::Ascii("dates"),
@@ -134326,12 +134326,12 @@ pub static WORD_GRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_GRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAT_CHILDREN),
+static WORD_GRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAT_CHILDREN),
     value: Some(&["great"]),
 };
 
-pub static WORD_GRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efull"),
         dictgen::InsensitiveStr::Ascii("ful"),
@@ -134369,12 +134369,12 @@ pub static WORD_GRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_GRAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAS_CHILDREN),
+static WORD_GRAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("srooots"),
         dictgen::InsensitiveStr::Ascii("srooters"),
@@ -134383,12 +134383,12 @@ pub static WORD_GRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_GRAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAP_CHILDREN),
+static WORD_GRAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efriut"),
         dictgen::InsensitiveStr::Ascii("efrukt"),
@@ -134426,23 +134426,23 @@ pub static WORD_GRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_GRAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAO_CHILDREN),
+static WORD_GRAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["graph"]],
     range: 1..=1,
 };
 
-static WORD_GRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAN_CHILDREN),
+static WORD_GRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("children"),
         dictgen::InsensitiveStr::Ascii("dchilden"),
@@ -134512,12 +134512,12 @@ pub static WORD_GRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_GRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAM_CHILDREN),
+static WORD_GRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("atical"),
@@ -134551,12 +134551,12 @@ pub static WORD_GRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_GRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAI_CHILDREN),
+static WORD_GRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dent"),
         dictgen::InsensitiveStr::Ascii("dents"),
@@ -134574,12 +134574,12 @@ pub static WORD_GRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_GRAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAH_CHILDREN),
+static WORD_GRAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ic"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -134603,12 +134603,12 @@ pub static WORD_GRAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_GRAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAF_CHILDREN),
+static WORD_GRAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ics"),
         dictgen::InsensitiveStr::Ascii("ield"),
@@ -134618,23 +134618,23 @@ pub static WORD_GRAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_GRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAE_CHILDREN),
+static WORD_GRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["great"]],
     range: 1..=1,
 };
 
-static WORD_GRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAD_CHILDREN),
+static WORD_GRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aully"),
         dictgen::InsensitiveStr::Ascii("iant"),
@@ -134664,12 +134664,12 @@ pub static WORD_GRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_GRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAC_CHILDREN),
+static WORD_GRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efull"),
         dictgen::InsensitiveStr::Ascii("efullly"),
@@ -134687,12 +134687,12 @@ pub static WORD_GRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_GRAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GRAB_CHILDREN),
+static WORD_GRAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GRAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GRAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -134703,23 +134703,23 @@ pub static WORD_GRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_GP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GP_CHILDREN),
+static WORD_GP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GP_CHILDREN),
     value: None,
 };
 
-pub static WORD_GP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ysies")],
     values: &[&["gypsies"]],
     range: 5..=5,
 };
 
-static WORD_GO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GO_CHILDREN),
+static WORD_GO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GO_CHILDREN),
     value: None,
 };
 
-static WORD_GO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GOA_NODE),
     Some(&WORD_GOB_NODE),
     Some(&WORD_GOC_NODE),
@@ -134748,12 +134748,12 @@ static WORD_GO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOV_CHILDREN),
+static WORD_GOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("emrent"),
@@ -134845,12 +134845,12 @@ pub static WORD_GOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_GOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOU_CHILDREN),
+static WORD_GOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("ped"),
@@ -134870,12 +134870,12 @@ pub static WORD_GOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_GOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOT_CHILDREN),
+static WORD_GOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ee"),
         dictgen::InsensitiveStr::Ascii("ees"),
@@ -134886,12 +134886,12 @@ pub static WORD_GOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_GOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOS_CHILDREN),
+static WORD_GOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("epls"),
         dictgen::InsensitiveStr::Ascii("pells"),
@@ -134902,12 +134902,12 @@ pub static WORD_GOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_GOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOR_CHILDREN),
+static WORD_GOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("egous"),
@@ -134953,12 +134953,12 @@ pub static WORD_GOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_GOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOO_CHILDREN),
+static WORD_GOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dlcuk"),
         dictgen::InsensitiveStr::Ascii("dluk"),
@@ -134984,12 +134984,12 @@ pub static WORD_GOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_GON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GON_CHILDREN),
+static WORD_GON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GON_CHILDREN),
     value: None,
 };
 
-pub static WORD_GON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ewidl"),
         dictgen::InsensitiveStr::Ascii("gratulations"),
@@ -134999,12 +134999,12 @@ pub static WORD_GON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_GOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOL_CHILDREN),
+static WORD_GOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aith"),
         dictgen::InsensitiveStr::Ascii("akeeper"),
@@ -135038,12 +135038,12 @@ pub static WORD_GOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_GOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOI_CHILDREN),
+static WORD_GOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gn"),
@@ -135063,12 +135063,12 @@ pub static WORD_GOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_GOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOG_CHILDREN),
+static WORD_GOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ether"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -135077,12 +135077,12 @@ pub static WORD_GOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_GOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOE_CHILDREN),
+static WORD_GOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("graphic"),
         dictgen::InsensitiveStr::Ascii("graphical"),
@@ -135104,12 +135104,12 @@ pub static WORD_GOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_GOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOD_CHILDREN),
+static WORD_GOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("afther"),
         dictgen::InsensitiveStr::Ascii("dammn"),
@@ -135149,23 +135149,23 @@ pub static WORD_GOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_GOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOC_CHILDREN),
+static WORD_GOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("de")],
     values: &[&["gcode"]],
     range: 2..=2,
 };
 
-static WORD_GOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOB_CHILDREN),
+static WORD_GOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("lings"),
@@ -135174,12 +135174,12 @@ pub static WORD_GOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_GOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GOA_CHILDREN),
+static WORD_GOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lkeaper"),
         dictgen::InsensitiveStr::Ascii("lkeepr"),
@@ -135195,12 +135195,12 @@ pub static WORD_GOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_GN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GN_CHILDREN),
+static WORD_GN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aking"),
         dictgen::InsensitiveStr::Ascii("awwed"),
@@ -135236,23 +135236,23 @@ pub static WORD_GN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_GM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GM_CHILDREN),
+static WORD_GM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GM_CHILDREN),
     value: None,
 };
 
-pub static WORD_GM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aertag")],
     values: &[&["gamertag"]],
     range: 6..=6,
 };
 
-static WORD_GL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GL_CHILDREN),
+static WORD_GL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adiatr"),
         dictgen::InsensitiveStr::Ascii("agsow"),
@@ -135368,12 +135368,12 @@ pub static WORD_GL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_GI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GI_CHILDREN),
+static WORD_GI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agbyte"),
         dictgen::InsensitiveStr::Ascii("en"),
@@ -135485,12 +135485,12 @@ pub static WORD_GI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_GH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GH_CHILDREN),
+static WORD_GH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GH_CHILDREN),
     value: None,
 };
 
-pub static WORD_GH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andi"),
         dictgen::InsensitiveStr::Ascii("ostcript"),
@@ -135508,12 +135508,12 @@ pub static WORD_GH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_GG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GG_CHILDREN),
+static WORD_GG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("od"),
         dictgen::InsensitiveStr::Ascii("ogle"),
@@ -135529,12 +135529,12 @@ pub static WORD_GG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_GE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GE_CHILDREN),
+static WORD_GE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GE_CHILDREN),
     value: None,
 };
 
-static WORD_GE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -135563,23 +135563,23 @@ static WORD_GE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GEU_CHILDREN),
+static WORD_GEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rrilla")],
     values: &[&["guerrilla"]],
     range: 6..=6,
 };
 
-static WORD_GET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GET_CHILDREN),
+static WORD_GET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GET_CHILDREN),
     value: None,
 };
 
-pub static WORD_GET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egories"),
         dictgen::InsensitiveStr::Ascii("fastproperyvalue"),
@@ -135627,23 +135627,23 @@ pub static WORD_GET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=16,
 };
 
-static WORD_GES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GES_CHILDREN),
+static WORD_GES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GES_CHILDREN),
     value: None,
 };
 
-pub static WORD_GES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["guess"]],
     range: 1..=1,
 };
 
-static WORD_GER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GER_CHILDREN),
+static WORD_GER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GER_CHILDREN),
     value: None,
 };
 
-pub static WORD_GER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aff"),
         dictgen::InsensitiveStr::Ascii("aphics"),
@@ -135731,12 +135731,12 @@ pub static WORD_GER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_GEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GEO_CHILDREN),
+static WORD_GEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("centic"),
         dictgen::InsensitiveStr::Ascii("emtries"),
@@ -135842,12 +135842,12 @@ pub static WORD_GEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_GEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GEN_CHILDREN),
+static WORD_GEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GEN_CHILDREN),
     value: None,
 };
 
-static WORD_GEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GENA_NODE),
     None,
     None,
@@ -135876,12 +135876,12 @@ static WORD_GEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GENU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENU_CHILDREN),
+static WORD_GENU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ienly"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -135901,12 +135901,12 @@ pub static WORD_GENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_GENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENT_CHILDREN),
+static WORD_GENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailia"),
         dictgen::InsensitiveStr::Ascii("al"),
@@ -135928,12 +135928,12 @@ pub static WORD_GENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_GENR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENR_CHILDREN),
+static WORD_GENR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alisation"),
@@ -135999,23 +135999,23 @@ pub static WORD_GENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_GENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENO_CHILDREN),
+static WORD_GENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mew")],
     values: &[&["genome"]],
     range: 3..=3,
 };
 
-static WORD_GENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENI_CHILDREN),
+static WORD_GENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alia"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -136047,12 +136047,12 @@ pub static WORD_GENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_GENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GENE_CHILDREN),
+static WORD_GENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GENE_CHILDREN),
     value: None,
 };
 
-static WORD_GENE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GENE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GENEA_NODE),
     None,
     None,
@@ -136081,12 +136081,12 @@ static WORD_GENE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GENET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENET_CHILDREN),
+static WORD_GENET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENET_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icaly"),
         dictgen::InsensitiveStr::Ascii("iclly"),
@@ -136096,12 +136096,12 @@ pub static WORD_GENET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_GENER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GENER_CHILDREN),
+static WORD_GENER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GENER_CHILDREN),
     value: None,
 };
 
-static WORD_GENER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GENER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_GENERA_NODE),
     None,
     None,
@@ -136130,12 +136130,12 @@ static WORD_GENER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GENERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERT_CHILDREN),
+static WORD_GENERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -136155,23 +136155,23 @@ pub static WORD_GENERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_GENERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERS_CHILDREN),
+static WORD_GENERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERS_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["generals"]],
     range: 1..=1,
 };
 
-static WORD_GENERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERO_CHILDREN),
+static WORD_GENERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ator"),
         dictgen::InsensitiveStr::Ascii("city"),
@@ -136189,12 +136189,12 @@ pub static WORD_GENERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_GENERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERL_CHILDREN),
+static WORD_GENERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("aizes"),
@@ -136204,12 +136204,12 @@ pub static WORD_GENERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_GENERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERI_CHILDREN),
+static WORD_GENERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lise"),
         dictgen::InsensitiveStr::Ascii("lised"),
@@ -136231,12 +136231,12 @@ pub static WORD_GENERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_GENERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERE_CHILDREN),
+static WORD_GENERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -136282,12 +136282,12 @@ pub static WORD_GENERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_GENERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENERA_CHILDREN),
+static WORD_GENERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("cional"),
@@ -136393,12 +136393,12 @@ pub static WORD_GENERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_GENEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENEO_CHILDREN),
+static WORD_GENEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logical"),
         dictgen::InsensitiveStr::Ascii("logies"),
@@ -136408,12 +136408,12 @@ pub static WORD_GENEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_GENEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENEN_CHILDREN),
+static WORD_GENEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erally"),
         dictgen::InsensitiveStr::Ascii("ric"),
@@ -136422,23 +136422,23 @@ pub static WORD_GENEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_GENEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENEI_CHILDREN),
+static WORD_GENEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("c")],
     values: &[&["generic", "genetic"]],
     range: 1..=1,
 };
 
-static WORD_GENEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENEA_CHILDREN),
+static WORD_GENEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ral"),
         dictgen::InsensitiveStr::Ascii("rally"),
@@ -136466,12 +136466,12 @@ pub static WORD_GENEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_GENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GENA_CHILDREN),
+static WORD_GENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_GENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ral"),
         dictgen::InsensitiveStr::Ascii("rate"),
@@ -136493,12 +136493,12 @@ pub static WORD_GENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_GEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GEM_CHILDREN),
+static WORD_GEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_GEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etrical"),
         dictgen::InsensitiveStr::Ascii("etry"),
@@ -136514,12 +136514,12 @@ pub static WORD_GEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_GEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GEE_CHILDREN),
+static WORD_GEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_GEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("neric"),
         dictgen::InsensitiveStr::Ascii("nrate"),
@@ -136543,12 +136543,12 @@ pub static WORD_GEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_GA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_GA_CHILDREN),
+static WORD_GA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_GA_CHILDREN),
     value: None,
 };
 
-static WORD_GA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_GA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_GAB_NODE),
     None,
@@ -136577,12 +136577,12 @@ static WORD_GA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_GAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAY_CHILDREN),
+static WORD_GAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ity"),
         dictgen::InsensitiveStr::Ascii("sha"),
@@ -136592,12 +136592,12 @@ pub static WORD_GAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_GAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAU_CHILDREN),
+static WORD_GAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("arana"),
@@ -136659,12 +136659,12 @@ pub static WORD_GAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_GAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAT_CHILDREN),
+static WORD_GAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -136684,23 +136684,23 @@ pub static WORD_GAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_GAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAS_CHILDREN),
+static WORD_GAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tly")],
     values: &[&["ghastly", "vastly"]],
     range: 3..=3,
 };
 
-static WORD_GAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAR_CHILDREN),
+static WORD_GAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abge"),
         dictgen::InsensitiveStr::Ascii("antee"),
@@ -136782,12 +136782,12 @@ pub static WORD_GAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_GAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAN_CHILDREN),
+static WORD_GAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bia"),
         dictgen::InsensitiveStr::Ascii("erate"),
@@ -136815,12 +136815,12 @@ pub static WORD_GAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_GAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAM_CHILDREN),
+static WORD_GAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAM_CHILDREN),
     value: Some(&["game"]),
 };
 
-pub static WORD_GAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emdoe"),
         dictgen::InsensitiveStr::Ascii("epaly"),
@@ -136842,12 +136842,12 @@ pub static WORD_GAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_GAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAL_CHILDREN),
+static WORD_GAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atic"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -136881,23 +136881,23 @@ pub static WORD_GAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_GAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAI_CHILDREN),
+static WORD_GAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nined")],
     values: &[&["gained"]],
     range: 5..=5,
 };
 
-static WORD_GAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAG_CHILDREN),
+static WORD_GAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dets"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -136915,12 +136915,12 @@ pub static WORD_GAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_GAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAD_CHILDREN),
+static WORD_GAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ged"),
         dictgen::InsensitiveStr::Ascii("gest"),
@@ -136929,23 +136929,23 @@ pub static WORD_GAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_GAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_GAB_CHILDREN),
+static WORD_GAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_GAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_GAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_GAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["garbage"]],
     range: 3..=3,
 };
 
-static WORD_F_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_F_CHILDREN),
+static WORD_F_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_F_CHILDREN),
     value: None,
 };
 
-static WORD_F_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_F_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FA_NODE),
     None,
     Some(&WORD_FC_NODE),
@@ -136974,12 +136974,12 @@ static WORD_F_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FY_CHILDREN),
+static WORD_FY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FY_CHILDREN),
     value: None,
 };
 
-pub static WORD_FY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ou"),
         dictgen::InsensitiveStr::Ascii("sical"),
@@ -136990,23 +136990,23 @@ pub static WORD_FY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FX_CHILDREN),
+static WORD_FX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["fixed"]],
     range: 2..=2,
 };
 
-static WORD_FW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FW_CHILDREN),
+static WORD_FW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ankenstein"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -137016,12 +137016,12 @@ pub static WORD_FW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_FU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FU_CHILDREN),
+static WORD_FU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FU_CHILDREN),
     value: None,
 };
 
-static WORD_FU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FUA_NODE),
     Some(&WORD_FUB_NODE),
     Some(&WORD_FUC_NODE),
@@ -137050,12 +137050,12 @@ static WORD_FU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUT_CHILDREN),
+static WORD_FUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -137101,12 +137101,12 @@ pub static WORD_FUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUS_CHILDREN),
+static WORD_FUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chia"),
         dictgen::InsensitiveStr::Ascii("ha"),
@@ -137132,12 +137132,12 @@ pub static WORD_FUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_FUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUR_CHILDREN),
+static WORD_FUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ctose"),
@@ -137253,12 +137253,12 @@ pub static WORD_FUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FUN_CHILDREN),
+static WORD_FUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FUN_CHILDREN),
     value: None,
 };
 
-static WORD_FUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FUN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_FUNC_NODE),
@@ -137287,12 +137287,12 @@ static WORD_FUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FUNX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNX_CHILDREN),
+static WORD_FUNX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tional"),
@@ -137314,12 +137314,12 @@ pub static WORD_FUNX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_FUNV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNV_CHILDREN),
+static WORD_FUNV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNV_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -137343,12 +137343,12 @@ pub static WORD_FUNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_FUNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNT_CHILDREN),
+static WORD_FUNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -137376,12 +137376,12 @@ pub static WORD_FUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_FUNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNR_CHILDREN),
+static WORD_FUNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("els"),
@@ -137390,12 +137390,12 @@ pub static WORD_FUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_FUNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNN_CHILDREN),
+static WORD_FUNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iliy"),
         dictgen::InsensitiveStr::Ascii("illy"),
@@ -137405,23 +137405,23 @@ pub static WORD_FUNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_FUNK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNK_CHILDREN),
+static WORD_FUNK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNK_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["function"]],
     range: 4..=4,
 };
 
-static WORD_FUNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNI_CHILDREN),
+static WORD_FUNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("des"),
         dictgen::InsensitiveStr::Ascii("ture"),
@@ -137430,23 +137430,23 @@ pub static WORD_FUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_FUNG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNG_CHILDREN),
+static WORD_FUNG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uses")],
     values: &[&["fungi"]],
     range: 4..=4,
 };
 
-static WORD_FUND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUND_CHILDREN),
+static WORD_FUND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUND_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amendalist"),
         dictgen::InsensitiveStr::Ascii("amendalists"),
@@ -137548,12 +137548,12 @@ pub static WORD_FUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=14,
 };
 
-static WORD_FUNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FUNC_CHILDREN),
+static WORD_FUNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FUNC_CHILDREN),
     value: None,
 };
 
-static WORD_FUNC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FUNC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FUNCA_NODE),
     None,
     None,
@@ -137582,23 +137582,23 @@ static WORD_FUNC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_FUNCZ_NODE),
 ];
 
-static WORD_FUNCZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCZ_CHILDREN),
+static WORD_FUNCZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ion")],
     values: &[&["function"]],
     range: 3..=3,
 };
 
-static WORD_FUNCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCT_CHILDREN),
+static WORD_FUNCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iion"),
         dictgen::InsensitiveStr::Ascii("iional"),
@@ -137724,12 +137724,12 @@ pub static WORD_FUNCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_FUNCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCS_CHILDREN),
+static WORD_FUNCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ions"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -137739,12 +137739,12 @@ pub static WORD_FUNCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_FUNCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCI_CHILDREN),
+static WORD_FUNCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("onal"),
@@ -137780,12 +137780,12 @@ pub static WORD_FUNCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_FUNCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCH_CHILDREN),
+static WORD_FUNCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tional"),
@@ -137813,12 +137813,12 @@ pub static WORD_FUNCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_FUNCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUNCA_CHILDREN),
+static WORD_FUNCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUNCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUNCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUNCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tionality"),
@@ -137827,12 +137827,12 @@ pub static WORD_FUNCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_FUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUM_CHILDREN),
+static WORD_FUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -137850,12 +137850,12 @@ pub static WORD_FUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_FUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUL_CHILDREN),
+static WORD_FUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUL_CHILDREN),
     value: Some(&["full"]),
 };
 
-pub static WORD_FUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("filed"),
@@ -137919,12 +137919,12 @@ pub static WORD_FUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUG_CHILDREN),
+static WORD_FUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ure"),
         dictgen::InsensitiveStr::Ascii("ured"),
@@ -137934,12 +137934,12 @@ pub static WORD_FUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_FUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUF_CHILDREN),
+static WORD_FUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ill"),
         dictgen::InsensitiveStr::Ascii("illed"),
@@ -137949,12 +137949,12 @@ pub static WORD_FUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_FUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUE_CHILDREN),
+static WORD_FUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("therst"),
         dictgen::InsensitiveStr::Ascii("thest"),
@@ -137963,12 +137963,12 @@ pub static WORD_FUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_FUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUC_CHILDREN),
+static WORD_FUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntion"),
         dictgen::InsensitiveStr::Ascii("ntional"),
@@ -138002,23 +138002,23 @@ pub static WORD_FUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_FUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUB_CHILDREN),
+static WORD_FUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ding")],
     values: &[&["funding"]],
     range: 4..=4,
 };
 
-static WORD_FUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FUA_CHILDREN),
+static WORD_FUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lt"),
         dictgen::InsensitiveStr::Ascii("lts"),
@@ -138027,12 +138027,12 @@ pub static WORD_FUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_FT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FT_CHILDREN),
+static WORD_FT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bs"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -138043,23 +138043,23 @@ pub static WORD_FT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_FS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FS_CHILDREN),
+static WORD_FS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("chk")],
     values: &[&["fsck"]],
     range: 3..=3,
 };
 
-static WORD_FR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FR_CHILDREN),
+static WORD_FR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FR_CHILDREN),
     value: None,
 };
 
-static WORD_FR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FRA_NODE),
     None,
     None,
@@ -138088,12 +138088,12 @@ static WORD_FR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRU_CHILDREN),
+static WORD_FRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adulent"),
         dictgen::InsensitiveStr::Ascii("itin"),
@@ -138151,12 +138151,12 @@ pub static WORD_FRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_FRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRS_CHILDREN),
+static WORD_FRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibee"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -138165,23 +138165,23 @@ pub static WORD_FRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_FRQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRQ_CHILDREN),
+static WORD_FRQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uency")],
     values: &[&["frequency"]],
     range: 5..=5,
 };
 
-static WORD_FRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRO_CHILDREN),
+static WORD_FRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("day"),
@@ -138285,12 +138285,12 @@ pub static WORD_FRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRM_CHILDREN),
+static WORD_FRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -138299,12 +138299,12 @@ pub static WORD_FRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_FRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRI_CHILDREN),
+static WORD_FRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cton"),
         dictgen::InsensitiveStr::Ascii("dey"),
@@ -138398,23 +138398,23 @@ pub static WORD_FRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_FRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRG_CHILDREN),
+static WORD_FRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ament")],
     values: &[&["fragment"]],
     range: 5..=5,
 };
 
-static WORD_FRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FRE_CHILDREN),
+static WORD_FRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FRE_CHILDREN),
     value: Some(&["free"]),
 };
 
-static WORD_FRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_FREC_NODE),
@@ -138443,12 +138443,12 @@ static WORD_FRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_FREZ_NODE),
 ];
 
-static WORD_FREZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREZ_CHILDREN),
+static WORD_FREZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -138457,23 +138457,23 @@ pub static WORD_FREZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_FRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRES_CHILDREN),
+static WORD_FRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hkly")],
     values: &[&["freshly"]],
     range: 4..=4,
 };
 
-static WORD_FREQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREQ_CHILDREN),
+static WORD_FREQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encies"),
         dictgen::InsensitiveStr::Ascii("ency"),
@@ -138537,12 +138537,12 @@ pub static WORD_FREQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_FREM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREM_CHILDREN),
+static WORD_FREM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entation"),
         dictgen::InsensitiveStr::Ascii("ented"),
@@ -138551,12 +138551,12 @@ pub static WORD_FREM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_FREI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREI_CHILDREN),
+static WORD_FREI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ndlies"),
@@ -138578,12 +138578,12 @@ pub static WORD_FREI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_FREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREE_CHILDREN),
+static WORD_FREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("callrelpy"),
         dictgen::InsensitiveStr::Ascii("deom"),
@@ -138623,12 +138623,12 @@ pub static WORD_FREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_FREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FREC_CHILDREN),
+static WORD_FREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kels"),
         dictgen::InsensitiveStr::Ascii("klers"),
@@ -138652,12 +138652,12 @@ pub static WORD_FREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_FRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FRA_CHILDREN),
+static WORD_FRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FRA_CHILDREN),
     value: None,
 };
 
-static WORD_FRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_FRAC_NODE),
@@ -138686,12 +138686,12 @@ static WORD_FRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FRAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAU_CHILDREN),
+static WORD_FRAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dalent"),
         dictgen::InsensitiveStr::Ascii("delant"),
@@ -138709,12 +138709,12 @@ pub static WORD_FRAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_FRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAT_CHILDREN),
+static WORD_FRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernaty"),
         dictgen::InsensitiveStr::Ascii("ernety"),
@@ -138732,12 +138732,12 @@ pub static WORD_FRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_FRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAN_CHILDREN),
+static WORD_FRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caises"),
         dictgen::InsensitiveStr::Ascii("ches"),
@@ -138807,12 +138807,12 @@ pub static WORD_FRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_FRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAM_CHILDREN),
+static WORD_FRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAM_CHILDREN),
     value: Some(&["frame"]),
 };
 
-pub static WORD_FRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("buffer"),
         dictgen::InsensitiveStr::Ascii("ebufer"),
@@ -138868,12 +138868,12 @@ pub static WORD_FRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_FRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAG_CHILDREN),
+static WORD_FRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ementation"),
@@ -138913,34 +138913,34 @@ pub static WORD_FRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_FRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAE_CHILDREN),
+static WORD_FRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("buffer")],
     values: &[&["framebuffer"]],
     range: 6..=6,
 };
 
-static WORD_FRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAD_CHILDREN),
+static WORD_FRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ulent")],
     values: &[&["fraudulent"]],
     range: 5..=5,
 };
 
-static WORD_FRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FRAC_CHILDREN),
+static WORD_FRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ional"),
         dictgen::InsensitiveStr::Ascii("kign"),
@@ -138970,12 +138970,12 @@ pub static WORD_FRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_FP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FP_CHILDREN),
+static WORD_FP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FP_CHILDREN),
     value: None,
 };
 
-pub static WORD_FP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -138986,12 +138986,12 @@ pub static WORD_FP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_FO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FO_CHILDREN),
+static WORD_FO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FO_CHILDREN),
     value: Some(&["of", "for", "do", "go", "to"]),
 };
 
-static WORD_FO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_FOC_NODE),
@@ -139020,12 +139020,12 @@ static WORD_FO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOW_CHILDREN),
+static WORD_FOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("arded"),
@@ -139047,12 +139047,12 @@ pub static WORD_FOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOU_CHILDREN),
+static WORD_FOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cs"),
         dictgen::InsensitiveStr::Ascii("csed"),
@@ -139112,12 +139112,12 @@ pub static WORD_FOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_FOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOT_CHILDREN),
+static WORD_FOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOT_CHILDREN),
     value: Some(&["for", "fit", "dot", "rot", "cot", "got", "tot", "fog"]),
 };
 
-pub static WORD_FOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("ograf"),
@@ -139139,12 +139139,12 @@ pub static WORD_FOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOS_CHILDREN),
+static WORD_FOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("siles"),
         dictgen::InsensitiveStr::Ascii("silis"),
@@ -139153,12 +139153,12 @@ pub static WORD_FOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_FOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FOR_CHILDREN),
+static WORD_FOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FOR_CHILDREN),
     value: None,
 };
 
-static WORD_FOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FORA_NODE),
     Some(&WORD_FORB_NODE),
     Some(&WORD_FORC_NODE),
@@ -139187,12 +139187,12 @@ static WORD_FOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FORW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORW_CHILDREN),
+static WORD_FORW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -139226,12 +139226,12 @@ pub static WORD_FORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_FORV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORV_CHILDREN),
+static WORD_FORV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORV_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atter"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -139240,12 +139240,12 @@ pub static WORD_FORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_FORU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORU_CHILDREN),
+static WORD_FORU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("la"),
         dictgen::InsensitiveStr::Ascii("las"),
@@ -139277,12 +139277,12 @@ pub static WORD_FORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_FORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORT_CHILDREN),
+static WORD_FORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -139332,12 +139332,12 @@ pub static WORD_FORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_FORS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORS_CHILDREN),
+static WORD_FORS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("akn"),
         dictgen::InsensitiveStr::Ascii("ane"),
@@ -139367,12 +139367,12 @@ pub static WORD_FORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORR_CHILDREN),
+static WORD_FORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORR_CHILDREN),
     value: Some(&["for"]),
 };
 
-pub static WORD_FORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esst"),
         dictgen::InsensitiveStr::Ascii("matter"),
@@ -139382,12 +139382,12 @@ pub static WORD_FORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_FORO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORO_CHILDREN),
+static WORD_FORO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tten"),
@@ -139396,12 +139396,12 @@ pub static WORD_FORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_FORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORN_CHILDREN),
+static WORD_FORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -139429,12 +139429,12 @@ pub static WORD_FORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FORM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORM_CHILDREN),
+static WORD_FORM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adible"),
         dictgen::InsensitiveStr::Ascii("alhaut"),
@@ -139568,12 +139568,12 @@ pub static WORD_FORM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_FORL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORL_CHILDREN),
+static WORD_FORL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -139583,12 +139583,12 @@ pub static WORD_FORL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_FORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORI_CHILDREN),
+static WORD_FORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cbly"),
         dictgen::InsensitiveStr::Ascii("egn"),
@@ -139616,23 +139616,23 @@ pub static WORD_FORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORH_CHILDREN),
+static WORD_FORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ead")],
     values: &[&["forehead"]],
     range: 3..=3,
 };
 
-static WORD_FORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORG_CHILDREN),
+static WORD_FORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ein"),
         dictgen::InsensitiveStr::Ascii("einer"),
@@ -139676,12 +139676,12 @@ pub static WORD_FORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_FORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORF_CHILDREN),
+static WORD_FORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iet"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -139699,12 +139699,12 @@ pub static WORD_FORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_FORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORE_CHILDREN),
+static WORD_FORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amrs"),
         dictgen::InsensitiveStr::Ascii("ard"),
@@ -139784,12 +139784,12 @@ pub static WORD_FORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_FORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORC_CHILDREN),
+static WORD_FORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ably"),
         dictgen::InsensitiveStr::Ascii("ast"),
@@ -139827,12 +139827,12 @@ pub static WORD_FORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_FORB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORB_CHILDREN),
+static WORD_FORB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("atum"),
@@ -139856,12 +139856,12 @@ pub static WORD_FORB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_FORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FORA_CHILDREN),
+static WORD_FORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matting"),
         dictgen::InsensitiveStr::Ascii("mt"),
@@ -139883,12 +139883,12 @@ pub static WORD_FORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_FOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOP_CHILDREN),
+static WORD_FOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("py"),
         dictgen::InsensitiveStr::Ascii("pys"),
@@ -139898,12 +139898,12 @@ pub static WORD_FOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_FOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOO_CHILDREN),
+static WORD_FOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntnotes"),
         dictgen::InsensitiveStr::Ascii("otball"),
@@ -139925,12 +139925,12 @@ pub static WORD_FOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_FON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FON_CHILDREN),
+static WORD_FON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FON_CHILDREN),
     value: None,
 };
 
-pub static WORD_FON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctional"),
@@ -139980,12 +139980,12 @@ pub static WORD_FON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_FOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOM_CHILDREN),
+static WORD_FOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOM_CHILDREN),
     value: Some(&["form", "from"]),
 };
 
-pub static WORD_FOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("at"),
@@ -140039,12 +140039,12 @@ pub static WORD_FOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_FOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FOL_CHILDREN),
+static WORD_FOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FOL_CHILDREN),
     value: None,
 };
 
-static WORD_FOL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FOL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -140073,23 +140073,23 @@ static WORD_FOL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FOLX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLX_CHILDREN),
+static WORD_FOLX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLX_CHILDREN),
     value: Some(&["folks"]),
 };
 
-pub static WORD_FOLX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FOLW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLW_CHILDREN),
+static WORD_FOLW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("o"),
         dictgen::InsensitiveStr::Ascii("oed"),
@@ -140121,23 +140121,23 @@ pub static WORD_FOLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FOLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLS_CHILDREN),
+static WORD_FOLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["false"]],
     range: 1..=1,
 };
 
-static WORD_FOLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLO_CHILDREN),
+static WORD_FOLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ow"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -140217,12 +140217,12 @@ pub static WORD_FOLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FOLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FOLL_CHILDREN),
+static WORD_FOLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FOLL_CHILDREN),
     value: None,
 };
 
-static WORD_FOLL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FOLL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -140251,12 +140251,12 @@ static WORD_FOLL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FOLLW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLW_CHILDREN),
+static WORD_FOLLW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLW_CHILDREN),
     value: Some(&["follow"]),
 };
 
-pub static WORD_FOLLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -140382,23 +140382,23 @@ pub static WORD_FOLLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FOLLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLS_CHILDREN),
+static WORD_FOLLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLS_CHILDREN),
     value: Some(&["follows"]),
 };
 
-pub static WORD_FOLLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FOLLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLO_CHILDREN),
+static WORD_FOLLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -140442,12 +140442,12 @@ pub static WORD_FOLLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FOLLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLL_CHILDREN),
+static WORD_FOLLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ow"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -140479,12 +140479,12 @@ pub static WORD_FOLLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_FOLLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLI_CHILDREN),
+static WORD_FOLLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nd"),
@@ -140528,12 +140528,12 @@ pub static WORD_FOLLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FOLLF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLF_CHILDREN),
+static WORD_FOLLF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ow"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -140565,12 +140565,12 @@ pub static WORD_FOLLF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_FOLLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLE_CHILDREN),
+static WORD_FOLLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -140608,23 +140608,23 @@ pub static WORD_FOLLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FOLLD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLLD_CHILDREN),
+static WORD_FOLLD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLLD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLLD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLLD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["folder"]],
     range: 2..=2,
 };
 
-static WORD_FOLF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLF_CHILDREN),
+static WORD_FOLF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -140633,12 +140633,12 @@ pub static WORD_FOLF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_FOLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLE_CHILDREN),
+static WORD_FOLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -140647,23 +140647,23 @@ pub static WORD_FOLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_FOLD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOLD_CHILDREN),
+static WORD_FOLD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOLD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOLD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOLD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["folder", "fold"]],
     range: 1..=1,
 };
 
-static WORD_FOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOI_CHILDREN),
+static WORD_FOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nters"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -140673,12 +140673,12 @@ pub static WORD_FOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOG_CHILDREN),
+static WORD_FOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -140689,23 +140689,23 @@ pub static WORD_FOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_FOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOF_CHILDREN),
+static WORD_FOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOF_CHILDREN),
     value: Some(&["for"]),
 };
 
-pub static WORD_FOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOD_CHILDREN),
+static WORD_FOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -140723,12 +140723,12 @@ pub static WORD_FOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_FOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FOC_CHILDREN),
+static WORD_FOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("u"),
@@ -140752,12 +140752,12 @@ pub static WORD_FOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FN_CHILDREN),
+static WORD_FN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aatic"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -140775,23 +140775,23 @@ pub static WORD_FN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_FM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FM_CHILDREN),
+static WORD_FM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aily")],
     values: &[&["family"]],
     range: 4..=4,
 };
 
-static WORD_FL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FL_CHILDREN),
+static WORD_FL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FL_CHILDREN),
     value: None,
 };
 
-static WORD_FL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FLA_NODE),
     None,
     Some(&WORD_FLC_NODE),
@@ -140820,23 +140820,23 @@ static WORD_FL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLY_CHILDREN),
+static WORD_FLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["flies", "flyers"]],
     range: 2..=2,
 };
 
-static WORD_FLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLU_CHILDREN),
+static WORD_FLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctaute"),
         dictgen::InsensitiveStr::Ascii("ctiations"),
@@ -140890,23 +140890,23 @@ pub static WORD_FLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLT_CHILDREN),
+static WORD_FLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["filter"]],
     range: 2..=2,
 };
 
-static WORD_FLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLO_CHILDREN),
+static WORD_FLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ading"),
         dictgen::InsensitiveStr::Ascii("aring"),
@@ -140954,23 +140954,23 @@ pub static WORD_FLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLL_CHILDREN),
+static WORD_FLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("owing")],
     values: &[&["following", "flowing"]],
     range: 5..=5,
 };
 
-static WORD_FLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLI_CHILDREN),
+static WORD_FLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ename"),
@@ -140996,12 +140996,12 @@ pub static WORD_FLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_FLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLE_CHILDREN),
+static WORD_FLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLE_CHILDREN),
     value: Some(&["file"]),
 };
 
-pub static WORD_FLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("chter"),
@@ -141053,23 +141053,23 @@ pub static WORD_FLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLC_CHILDREN),
+static WORD_FLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iker")],
     values: &[&["flicker"]],
     range: 4..=4,
 };
 
-static WORD_FLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FLA_CHILDREN),
+static WORD_FLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cons"),
         dictgen::InsensitiveStr::Ascii("cor"),
@@ -141195,12 +141195,12 @@ pub static WORD_FLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FI_CHILDREN),
+static WORD_FI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FI_CHILDREN),
     value: None,
 };
 
-static WORD_FI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FIA_NODE),
     Some(&WORD_FIB_NODE),
     Some(&WORD_FIC_NODE),
@@ -141229,23 +141229,23 @@ static WORD_FI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_FIZ_NODE),
 ];
 
-static WORD_FIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIZ_CHILDREN),
+static WORD_FIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eek")],
     values: &[&["physique"]],
     range: 3..=3,
 };
 
-static WORD_FIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIX_CHILDREN),
+static WORD_FIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -141265,34 +141265,34 @@ pub static WORD_FIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_FIW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIW_CHILDREN),
+static WORD_FIW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIW_CHILDREN),
     value: Some(&["fix"]),
 };
 
-pub static WORD_FIW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIV_CHILDREN),
+static WORD_FIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ety")],
     values: &[&["fifty"]],
     range: 3..=3,
 };
 
-static WORD_FIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIT_CHILDREN),
+static WORD_FIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ering"),
@@ -141316,12 +141316,12 @@ pub static WORD_FIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_FIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIS_CHILDREN),
+static WORD_FIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ionable"),
@@ -141339,12 +141339,12 @@ pub static WORD_FIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_FIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIR_CHILDREN),
+static WORD_FIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ball"),
         dictgen::InsensitiveStr::Ascii("day"),
@@ -141442,12 +141442,12 @@ pub static WORD_FIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIO_CHILDREN),
+static WORD_FIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rget"),
@@ -141457,12 +141457,12 @@ pub static WORD_FIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_FIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FIN_CHILDREN),
+static WORD_FIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FIN_CHILDREN),
     value: None,
 };
 
-static WORD_FIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FINA_NODE),
     None,
     Some(&WORD_FINC_NODE),
@@ -141491,12 +141491,12 @@ static WORD_FIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FINX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINX_CHILDREN),
+static WORD_FINX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -141505,12 +141505,12 @@ pub static WORD_FINX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_FINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINT_CHILDREN),
+static WORD_FINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("uned"),
@@ -141519,12 +141519,12 @@ pub static WORD_FINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_FINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINS_CHILDREN),
+static WORD_FINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("hed"),
@@ -141550,12 +141550,12 @@ pub static WORD_FINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FINN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINN_CHILDREN),
+static WORD_FINN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aly"),
         dictgen::InsensitiveStr::Ascii("ess"),
@@ -141573,12 +141573,12 @@ pub static WORD_FINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_FINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINI_CHILDREN),
+static WORD_FINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alization"),
         dictgen::InsensitiveStr::Ascii("alize"),
@@ -141626,12 +141626,12 @@ pub static WORD_FINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_FING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FING_CHILDREN),
+static WORD_FING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FING_CHILDREN),
     value: Some(&["find"]),
 };
 
-pub static WORD_FING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eprint"),
@@ -141667,23 +141667,23 @@ pub static WORD_FING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_FINF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINF_CHILDREN),
+static WORD_FINF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINF_CHILDREN),
     value: Some(&["find"]),
 };
 
-pub static WORD_FINF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_FINE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINE_CHILDREN),
+static WORD_FINE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lly"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -141694,12 +141694,12 @@ pub static WORD_FINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_FIND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIND_CHILDREN),
+static WORD_FIND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIND_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -141709,12 +141709,12 @@ pub static WORD_FIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_FINC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINC_CHILDREN),
+static WORD_FINC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("ial"),
@@ -141734,12 +141734,12 @@ pub static WORD_FINC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_FINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FINA_CHILDREN),
+static WORD_FINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cee"),
@@ -141793,12 +141793,12 @@ pub static WORD_FINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_FIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIM_CHILDREN),
+static WORD_FIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ilies"),
@@ -141814,12 +141814,12 @@ pub static WORD_FIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FIL_CHILDREN),
+static WORD_FIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FIL_CHILDREN),
     value: None,
 };
 
-static WORD_FIL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FIL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FILA_NODE),
     None,
     Some(&WORD_FILC_NODE),
@@ -141848,12 +141848,12 @@ static WORD_FIL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FILT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILT_CHILDREN),
+static WORD_FILT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erd"),
         dictgen::InsensitiveStr::Ascii("erig"),
@@ -141879,12 +141879,12 @@ pub static WORD_FILT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_FILS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILS_CHILDREN),
+static WORD_FILS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILS_CHILDREN),
     value: Some(&["fills", "files", "file"]),
 };
 
-pub static WORD_FILS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ystem"),
@@ -141894,12 +141894,12 @@ pub static WORD_FILS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_FILP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILP_CHILDREN),
+static WORD_FILP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILP_CHILDREN),
     value: Some(&["flip"]),
 };
 
-pub static WORD_FILP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ped"),
         dictgen::InsensitiveStr::Ascii("ping"),
@@ -141909,12 +141909,12 @@ pub static WORD_FILP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_FILN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILN_CHILDREN),
+static WORD_FILN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ame"),
@@ -141923,12 +141923,12 @@ pub static WORD_FILN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_FILM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILM_CHILDREN),
+static WORD_FILM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amkers"),
         dictgen::InsensitiveStr::Ascii("makare"),
@@ -141938,12 +141938,12 @@ pub static WORD_FILM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_FILL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILL_CHILDREN),
+static WORD_FILL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -141965,12 +141965,12 @@ pub static WORD_FILL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_FILI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILI_CHILDREN),
+static WORD_FILI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ament"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -141979,23 +141979,23 @@ pub static WORD_FILI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_FILF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILF_CHILDREN),
+static WORD_FILF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ills")],
     values: &[&["fulfills"]],
     range: 4..=4,
 };
 
-static WORD_FILE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILE_CHILDREN),
+static WORD_FILE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bame"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -142065,45 +142065,45 @@ pub static WORD_FILE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_FILC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILC_CHILDREN),
+static WORD_FILC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ker")],
     values: &[&["flicker"]],
     range: 3..=3,
 };
 
-static WORD_FILA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FILA_CHILDREN),
+static WORD_FILA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FILA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FILA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FILA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["final"]],
     range: 1..=1,
 };
 
-static WORD_FIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIK_CHILDREN),
+static WORD_FIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIK_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["file"]],
     range: 1..=1,
 };
 
-static WORD_FIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIG_CHILDREN),
+static WORD_FIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hitng"),
         dictgen::InsensitiveStr::Ascii("htings"),
@@ -142139,12 +142139,12 @@ pub static WORD_FIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=10,
 };
 
-static WORD_FIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIF_CHILDREN),
+static WORD_FIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erox"),
         dictgen::InsensitiveStr::Ascii("ferent"),
@@ -142154,12 +142154,12 @@ pub static WORD_FIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIE_CHILDREN),
+static WORD_FIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dl"),
@@ -142201,12 +142201,12 @@ pub static WORD_FIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FID_CHILDREN),
+static WORD_FID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FID_CHILDREN),
     value: None,
 };
 
-pub static WORD_FID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ality"),
         dictgen::InsensitiveStr::Ascii("dley"),
@@ -142228,12 +142228,12 @@ pub static WORD_FID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIC_CHILDREN),
+static WORD_FIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ks"),
         dictgen::InsensitiveStr::Ascii("ticious"),
@@ -142253,12 +142253,12 @@ pub static WORD_FIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIB_CHILDREN),
+static WORD_FIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onaacci"),
         dictgen::InsensitiveStr::Ascii("onnacci"),
@@ -142267,12 +142267,12 @@ pub static WORD_FIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=7,
 };
 
-static WORD_FIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FIA_CHILDREN),
+static WORD_FIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ls"),
         dictgen::InsensitiveStr::Ascii("ncial"),
@@ -142290,23 +142290,23 @@ pub static WORD_FIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_FH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FH_CHILDREN),
+static WORD_FH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FH_CHILDREN),
     value: None,
 };
 
-pub static WORD_FH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("urter")],
     values: &[&["further"]],
     range: 5..=5,
 };
 
-static WORD_FF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FF_CHILDREN),
+static WORD_FF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FF_CHILDREN),
     value: None,
 };
 
-pub static WORD_FF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("rom"),
@@ -142315,12 +142315,12 @@ pub static WORD_FF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_FE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FE_CHILDREN),
+static WORD_FE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FE_CHILDREN),
     value: None,
 };
 
-static WORD_FE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_FEA_NODE),
     Some(&WORD_FEB_NODE),
     Some(&WORD_FEC_NODE),
@@ -142349,34 +142349,34 @@ static WORD_FE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_FEZ_NODE),
 ];
 
-static WORD_FEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEZ_CHILDREN),
+static WORD_FEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ent")],
     values: &[&["pheasant"]],
     range: 3..=3,
 };
 
-static WORD_FEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEX_CHILDREN),
+static WORD_FEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ibility")],
     values: &[&["flexibility"]],
     range: 7..=7,
 };
 
-static WORD_FEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEW_CHILDREN),
+static WORD_FEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -142386,12 +142386,12 @@ pub static WORD_FEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_FET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FET_CHILDREN),
+static WORD_FET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FET_CHILDREN),
     value: None,
 };
 
-pub static WORD_FET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aure"),
         dictgen::InsensitiveStr::Ascii("aures"),
@@ -142419,12 +142419,12 @@ pub static WORD_FET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_FES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FES_CHILDREN),
+static WORD_FES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FES_CHILDREN),
     value: None,
 };
 
-pub static WORD_FES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("itvals"),
@@ -142446,12 +142446,12 @@ pub static WORD_FES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_FER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FER_CHILDREN),
+static WORD_FER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FER_CHILDREN),
     value: None,
 };
 
-pub static WORD_FER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("buary"),
         dictgen::InsensitiveStr::Ascii("mantation"),
@@ -142497,23 +142497,23 @@ pub static WORD_FER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_FEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEQ_CHILDREN),
+static WORD_FEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uency")],
     values: &[&["frequency"]],
     range: 5..=5,
 };
 
-static WORD_FEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEO_CHILDREN),
+static WORD_FEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dras"),
         dictgen::InsensitiveStr::Ascii("nsay"),
@@ -142522,12 +142522,12 @@ pub static WORD_FEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_FEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEM_CHILDREN),
+static WORD_FEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inen"),
         dictgen::InsensitiveStr::Ascii("inie"),
@@ -142563,12 +142563,12 @@ pub static WORD_FEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_FEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEL_CHILDREN),
+static WORD_FEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("isatus"),
@@ -142590,12 +142590,12 @@ pub static WORD_FEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_FEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEI_CHILDREN),
+static WORD_FEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("lding"),
@@ -142613,12 +142613,12 @@ pub static WORD_FEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_FEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEE_CHILDREN),
+static WORD_FEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("back"),
         dictgen::InsensitiveStr::Ascii("dbakc"),
@@ -142642,12 +142642,12 @@ pub static WORD_FEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_FED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FED_CHILDREN),
+static WORD_FED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FED_CHILDREN),
     value: None,
 };
 
-pub static WORD_FED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ality"),
         dictgen::InsensitiveStr::Ascii("back"),
@@ -142673,12 +142673,12 @@ pub static WORD_FED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_FEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEC_CHILDREN),
+static WORD_FEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hes"),
         dictgen::InsensitiveStr::Ascii("thed"),
@@ -142689,12 +142689,12 @@ pub static WORD_FEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_FEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEB_CHILDREN),
+static WORD_FEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bruary"),
         dictgen::InsensitiveStr::Ascii("ewary"),
@@ -142718,12 +142718,12 @@ pub static WORD_FEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_FEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FEA_CHILDREN),
+static WORD_FEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_FEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ls"),
         dictgen::InsensitiveStr::Ascii("sabile"),
@@ -142791,23 +142791,23 @@ pub static WORD_FEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_FC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FC_CHILDREN),
+static WORD_FC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ound")],
     values: &[&["found"]],
     range: 4..=4,
 };
 
-static WORD_FA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_FA_CHILDREN),
+static WORD_FA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_FA_CHILDREN),
     value: None,
 };
 
-static WORD_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_FA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_FAB_NODE),
     Some(&WORD_FAC_NODE),
@@ -142836,23 +142836,23 @@ static WORD_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_FAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAY_CHILDREN),
+static WORD_FAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mus")],
     values: &[&["famous"]],
     range: 3..=3,
 };
 
-static WORD_FAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAV_CHILDREN),
+static WORD_FAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orit"),
         dictgen::InsensitiveStr::Ascii("oritisme"),
@@ -142892,12 +142892,12 @@ pub static WORD_FAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_FAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAU_CHILDREN),
+static WORD_FAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ght"),
         dictgen::InsensitiveStr::Ascii("ilure"),
@@ -142929,12 +142929,12 @@ pub static WORD_FAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAT_CHILDREN),
+static WORD_FAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alaties"),
         dictgen::InsensitiveStr::Ascii("alitites"),
@@ -142962,12 +142962,12 @@ pub static WORD_FAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_FAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAS_CHILDREN),
+static WORD_FAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("cianted"),
@@ -143083,12 +143083,12 @@ pub static WORD_FAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_FAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAR_CHILDREN),
+static WORD_FAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cking"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -143130,34 +143130,34 @@ pub static WORD_FAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_FAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAP_CHILDREN),
+static WORD_FAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tastically")],
     values: &[&["fantastically"]],
     range: 10..=10,
 };
 
-static WORD_FAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAO_CHILDREN),
+static WORD_FAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ming")],
     values: &[&["foaming"]],
     range: 4..=4,
 };
 
-static WORD_FAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAN_CHILDREN),
+static WORD_FAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aticals"),
         dictgen::InsensitiveStr::Ascii("aticas"),
@@ -143245,12 +143245,12 @@ pub static WORD_FAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_FAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAM_CHILDREN),
+static WORD_FAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ework"),
         dictgen::InsensitiveStr::Ascii("ilair"),
@@ -143316,12 +143316,12 @@ pub static WORD_FAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_FAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAL_CHILDREN),
+static WORD_FAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cones"),
         dictgen::InsensitiveStr::Ascii("esly"),
@@ -143401,12 +143401,12 @@ pub static WORD_FAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_FAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAK_CHILDREN),
+static WORD_FAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("tor"),
@@ -143424,12 +143424,12 @@ pub static WORD_FAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAI_CHILDREN),
+static WORD_FAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eld"),
@@ -143521,12 +143521,12 @@ pub static WORD_FAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_FAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAH_CHILDREN),
+static WORD_FAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernheit"),
         dictgen::InsensitiveStr::Ascii("renheight"),
@@ -143536,12 +143536,12 @@ pub static WORD_FAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=9,
 };
 
-static WORD_FAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAG_CHILDREN),
+static WORD_FAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gotts"),
         dictgen::InsensitiveStr::Ascii("gotus"),
@@ -143550,12 +143550,12 @@ pub static WORD_FAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_FAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAE_CHILDREN),
+static WORD_FAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ture"),
         dictgen::InsensitiveStr::Ascii("tures"),
@@ -143564,23 +143564,23 @@ pub static WORD_FAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_FAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAD_CHILDREN),
+static WORD_FAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ind")],
     values: &[&["fading"]],
     range: 3..=3,
 };
 
-static WORD_FAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAC_CHILDREN),
+static WORD_FAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ebok"),
@@ -143706,12 +143706,12 @@ pub static WORD_FAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_FAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_FAB_CHILDREN),
+static WORD_FAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_FAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_FAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_FAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ility"),
         dictgen::InsensitiveStr::Ascii("ircate"),
@@ -143749,12 +143749,12 @@ pub static WORD_FAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_E_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_E_CHILDREN),
+static WORD_E_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_E_CHILDREN),
     value: None,
 };
 
-static WORD_E_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_E_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EA_NODE),
     Some(&WORD_EB_NODE),
     Some(&WORD_EC_NODE),
@@ -143783,23 +143783,23 @@ static WORD_E_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_EZ_NODE),
 ];
 
-static WORD_EZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EZ_CHILDREN),
+static WORD_EZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_EZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("drop")],
     values: &[&["eavesdrop"]],
     range: 4..=4,
 };
 
-static WORD_EY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EY_CHILDREN),
+static WORD_EY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EY_CHILDREN),
     value: None,
 };
 
-pub static WORD_EY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -143841,12 +143841,12 @@ pub static WORD_EY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_EX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EX_CHILDREN),
+static WORD_EX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EX_CHILDREN),
     value: None,
 };
 
-static WORD_EX_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EX_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXA_NODE),
     None,
     Some(&WORD_EXC_NODE),
@@ -143875,12 +143875,12 @@ static WORD_EX_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXU_CHILDREN),
+static WORD_EXU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("berent"),
         dictgen::InsensitiveStr::Ascii("cuted"),
@@ -143898,12 +143898,12 @@ pub static WORD_EXU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_EXT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXT_CHILDREN),
+static WORD_EXT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXT_CHILDREN),
     value: None,
 };
 
-static WORD_EXT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXTA_NODE),
     None,
     None,
@@ -143932,12 +143932,12 @@ static WORD_EXT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTU_CHILDREN),
+static WORD_EXTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rde"),
@@ -143955,34 +143955,34 @@ pub static WORD_EXTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTT_CHILDREN),
+static WORD_EXTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ra")],
     values: &[&["extra"]],
     range: 2..=2,
 };
 
-static WORD_EXTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTS_CHILDREN),
+static WORD_EXTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["existing"]],
     range: 3..=3,
 };
 
-static WORD_EXTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXTR_CHILDREN),
+static WORD_EXTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXTR_CHILDREN),
     value: None,
 };
 
-static WORD_EXTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXTRA_NODE),
     None,
     None,
@@ -144011,34 +144011,34 @@ static WORD_EXTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXTRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRY_CHILDREN),
+static WORD_EXTRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRY_CHILDREN),
     value: Some(&["entry"]),
 };
 
-pub static WORD_EXTRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRU_CHILDREN),
+static WORD_EXTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ciating")],
     values: &[&["excruciating"]],
     range: 7..=7,
 };
 
-static WORD_EXTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRO_CHILDREN),
+static WORD_EXTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ardinarily"),
         dictgen::InsensitiveStr::Ascii("ardinary"),
@@ -144060,23 +144060,23 @@ pub static WORD_EXTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_EXTRM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRM_CHILDREN),
+static WORD_EXTRM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ities")],
     values: &[&["extremities"]],
     range: 5..=5,
 };
 
-static WORD_EXTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRI_CHILDREN),
+static WORD_EXTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("me"),
         dictgen::InsensitiveStr::Ascii("mely"),
@@ -144096,12 +144096,12 @@ pub static WORD_EXTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRE_CHILDREN),
+static WORD_EXTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("amely"),
@@ -144183,12 +144183,12 @@ pub static WORD_EXTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_EXTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXTRA_CHILDREN),
+static WORD_EXTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXTRA_CHILDREN),
     value: None,
 };
 
-static WORD_EXTRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXTRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXTRAC_NODE),
@@ -144217,12 +144217,12 @@ static WORD_EXTRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXTRAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAX_CHILDREN),
+static WORD_EXTRAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -144240,12 +144240,12 @@ pub static WORD_EXTRAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_EXTRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAV_CHILDREN),
+static WORD_EXTRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agent"),
         dictgen::InsensitiveStr::Ascii("agina"),
@@ -144265,12 +144265,12 @@ pub static WORD_EXTRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_EXTRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAT_CHILDREN),
+static WORD_EXTRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAT_CHILDREN),
     value: Some(&["extract"]),
 };
 
-pub static WORD_EXTRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("errestial"),
@@ -144296,12 +144296,12 @@ pub static WORD_EXTRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_EXTRAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAP_CHILDREN),
+static WORD_EXTRAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("loate"),
@@ -144329,12 +144329,12 @@ pub static WORD_EXTRAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_EXTRAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAO_CHILDREN),
+static WORD_EXTRAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("drinarily"),
         dictgen::InsensitiveStr::Ascii("drinary"),
@@ -144372,12 +144372,12 @@ pub static WORD_EXTRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=10,
 };
 
-static WORD_EXTRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAN_CHILDREN),
+static WORD_EXTRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -144386,34 +144386,34 @@ pub static WORD_EXTRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_EXTRAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAG_CHILDREN),
+static WORD_EXTRAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("avant")],
     values: &[&["extravagant"]],
     range: 5..=5,
 };
 
-static WORD_EXTRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAE_CHILDREN),
+static WORD_EXTRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nous")],
     values: &[&["extraneous"]],
     range: 4..=4,
 };
 
-static WORD_EXTRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAD_CHILDREN),
+static WORD_EXTRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iction"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -144422,12 +144422,12 @@ pub static WORD_EXTRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_EXTRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTRAC_CHILDREN),
+static WORD_EXTRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTRAC_CHILDREN),
     value: Some(&["extract"]),
 };
 
-pub static WORD_EXTRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cion"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -144461,12 +144461,12 @@ pub static WORD_EXTRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_EXTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTO_CHILDREN),
+static WORD_EXTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ics"),
         dictgen::InsensitiveStr::Ascii("rtin"),
@@ -144475,12 +144475,12 @@ pub static WORD_EXTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EXTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTN_CHILDREN),
+static WORD_EXTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("end"),
         dictgen::InsensitiveStr::Ascii("esion"),
@@ -144490,12 +144490,12 @@ pub static WORD_EXTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTI_CHILDREN),
+static WORD_EXTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mate"),
         dictgen::InsensitiveStr::Ascii("mated"),
@@ -144535,12 +144535,12 @@ pub static WORD_EXTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXTE_CHILDREN),
+static WORD_EXTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXTE_CHILDREN),
     value: None,
 };
 
-static WORD_EXTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXTE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -144569,12 +144569,12 @@ static WORD_EXTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXTES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTES_CHILDREN),
+static WORD_EXTES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTES_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -144590,12 +144590,12 @@ pub static WORD_EXTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_EXTER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTER_CHILDREN),
+static WORD_EXTER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTER_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("bal"),
@@ -144647,12 +144647,12 @@ pub static WORD_EXTER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_EXTEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTEP_CHILDREN),
+static WORD_EXTEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ecting"),
@@ -144662,12 +144662,12 @@ pub static WORD_EXTEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXTEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTEN_CHILDREN),
+static WORD_EXTEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTEN_CHILDREN),
     value: Some(&["extent"]),
 };
 
-pub static WORD_EXTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -144747,23 +144747,23 @@ pub static WORD_EXTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_EXTEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTEM_CHILDREN),
+static WORD_EXTEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXTEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ely")],
     values: &[&["extremely"]],
     range: 3..=3,
 };
 
-static WORD_EXTED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTED_CHILDREN),
+static WORD_EXTED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTED_CHILDREN),
     value: Some(&["extend"]),
 };
 
-pub static WORD_EXTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -144787,12 +144787,12 @@ pub static WORD_EXTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_EXTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXTA_CHILDREN),
+static WORD_EXTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXTA_CHILDREN),
     value: Some(&["extra"]),
 };
 
-pub static WORD_EXTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -144814,12 +144814,12 @@ pub static WORD_EXTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXS_CHILDREN),
+static WORD_EXS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ist"),
         dictgen::InsensitiveStr::Ascii("istence"),
@@ -144879,12 +144879,12 @@ pub static WORD_EXS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EXR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXR_CHILDREN),
+static WORD_EXR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("act"),
@@ -144906,12 +144906,12 @@ pub static WORD_EXR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_EXP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXP_CHILDREN),
+static WORD_EXP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXP_CHILDREN),
     value: None,
 };
 
-static WORD_EXP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPA_NODE),
     None,
     Some(&WORD_EXPC_NODE),
@@ -144940,23 +144940,23 @@ static WORD_EXP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPT_CHILDREN),
+static WORD_EXPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ected")],
     values: &[&["expected"]],
     range: 5..=5,
 };
 
-static WORD_EXPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPR_CHILDREN),
+static WORD_EXPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eince"),
         dictgen::InsensitiveStr::Ascii("ensive"),
@@ -145060,12 +145060,12 @@ pub static WORD_EXPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_EXPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPP_CHILDREN),
+static WORD_EXPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ort"),
         dictgen::InsensitiveStr::Ascii("ressed"),
@@ -145074,12 +145074,12 @@ pub static WORD_EXPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPO_CHILDREN),
+static WORD_EXPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPO_CHILDREN),
     value: None,
 };
 
-static WORD_EXPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXPOC_NODE),
@@ -145108,12 +145108,12 @@ static WORD_EXPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOT_CHILDREN),
+static WORD_EXPOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ential"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -145123,12 +145123,12 @@ pub static WORD_EXPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXPOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOS_CHILDREN),
+static WORD_EXPOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ees"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -145148,12 +145148,12 @@ pub static WORD_EXPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXPOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOR_CHILDREN),
+static WORD_EXPOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ession"),
@@ -145179,12 +145179,12 @@ pub static WORD_EXPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXPON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPON_CHILDREN),
+static WORD_EXPON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPON_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("antation"),
@@ -145228,12 +145228,12 @@ pub static WORD_EXPON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_EXPOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOL_CHILDREN),
+static WORD_EXPOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("des"),
@@ -145267,12 +145267,12 @@ pub static WORD_EXPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXPOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOI_CHILDREN),
+static WORD_EXPOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tation"),
@@ -145288,12 +145288,12 @@ pub static WORD_EXPOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXPOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOE_CHILDREN),
+static WORD_EXPOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cted"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -145317,12 +145317,12 @@ pub static WORD_EXPOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOD_CHILDREN),
+static WORD_EXPOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ential"),
         dictgen::InsensitiveStr::Ascii("entially"),
@@ -145332,23 +145332,23 @@ pub static WORD_EXPOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_EXPOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPOC_CHILDREN),
+static WORD_EXPOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("h")],
     values: &[&["epoch"]],
     range: 1..=1,
 };
 
-static WORD_EXPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPL_CHILDREN),
+static WORD_EXPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPL_CHILDREN),
     value: None,
 };
 
-static WORD_EXPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPLA_NODE),
     None,
     Some(&WORD_EXPLC_NODE),
@@ -145377,23 +145377,23 @@ static WORD_EXPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLU_CHILDREN),
+static WORD_EXPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sions")],
     values: &[&["explosions"]],
     range: 5..=5,
 };
 
-static WORD_EXPLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLO_CHILDREN),
+static WORD_EXPLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deds"),
         dictgen::InsensitiveStr::Ascii("die"),
@@ -145479,12 +145479,12 @@ pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLI_CHILDREN),
+static WORD_EXPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("cat"),
@@ -145590,12 +145590,12 @@ pub static WORD_EXPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLE_CHILDREN),
+static WORD_EXPLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cit"),
         dictgen::InsensitiveStr::Ascii("citely"),
@@ -145617,12 +145617,12 @@ pub static WORD_EXPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EXPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLC_CHILDREN),
+static WORD_EXPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("itely"),
@@ -145632,12 +145632,12 @@ pub static WORD_EXPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPLA_CHILDREN),
+static WORD_EXPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ination"),
         dictgen::InsensitiveStr::Ascii("inations"),
@@ -145695,12 +145695,12 @@ pub static WORD_EXPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_EXPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPI_CHILDREN),
+static WORD_EXPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cit"),
         dictgen::InsensitiveStr::Ascii("citly"),
@@ -145782,12 +145782,12 @@ pub static WORD_EXPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_EXPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPE_CHILDREN),
+static WORD_EXPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPE_CHILDREN),
     value: None,
 };
 
-static WORD_EXPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXPEC_NODE),
@@ -145816,12 +145816,12 @@ static WORD_EXPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEX_CHILDREN),
+static WORD_EXPEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -145855,12 +145855,12 @@ pub static WORD_EXPEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEW_CHILDREN),
+static WORD_EXPEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("riment"),
         dictgen::InsensitiveStr::Ascii("rimental"),
@@ -145892,12 +145892,12 @@ pub static WORD_EXPEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=12,
 };
 
-static WORD_EXPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPET_CHILDREN),
+static WORD_EXPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPET_CHILDREN),
     value: Some(&["expect", "expat"]),
 };
 
-pub static WORD_EXPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancy"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -145979,12 +145979,12 @@ pub static WORD_EXPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_EXPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPES_CHILDREN),
+static WORD_EXPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -146026,12 +146026,12 @@ pub static WORD_EXPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_EXPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPER_CHILDREN),
+static WORD_EXPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPER_CHILDREN),
     value: None,
 };
 
-static WORD_EXPER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPERA_NODE),
     None,
     Some(&WORD_EXPERC_NODE),
@@ -146060,12 +146060,12 @@ static WORD_EXPER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERT_CHILDREN),
+static WORD_EXPERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -146076,12 +146076,12 @@ pub static WORD_EXPERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_EXPERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERS_CHILDREN),
+static WORD_EXPERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERS_CHILDREN),
     value: Some(&["express"]),
 };
 
-pub static WORD_EXPERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -146115,23 +146115,23 @@ pub static WORD_EXPERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_EXPERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERN_CHILDREN),
+static WORD_EXPERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["external"]],
     range: 2..=2,
 };
 
-static WORD_EXPERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERM_CHILDREN),
+static WORD_EXPERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enet"),
         dictgen::InsensitiveStr::Ascii("enetal"),
@@ -146247,12 +146247,12 @@ pub static WORD_EXPERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=11,
 };
 
-static WORD_EXPERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPERI_CHILDREN),
+static WORD_EXPERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPERI_CHILDREN),
     value: None,
 };
 
-static WORD_EXPERI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPERI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPERIA_NODE),
     None,
     Some(&WORD_EXPERIC_NODE),
@@ -146281,12 +146281,12 @@ static WORD_EXPERI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPERIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIR_CHILDREN),
+static WORD_EXPERIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -146295,12 +146295,12 @@ pub static WORD_EXPERIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=6,
 };
 
-static WORD_EXPERIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIN_CHILDREN),
+static WORD_EXPERIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -146344,12 +146344,12 @@ pub static WORD_EXPERIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=11,
 };
 
-static WORD_EXPERIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPERIM_CHILDREN),
+static WORD_EXPERIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPERIM_CHILDREN),
     value: Some(&["experiment"]),
 };
 
-static WORD_EXPERIM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPERIM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPERIMA_NODE),
     None,
     None,
@@ -146378,12 +146378,12 @@ static WORD_EXPERIM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPERIMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMT_CHILDREN),
+static WORD_EXPERIMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("enal"),
@@ -146415,23 +146415,23 @@ pub static WORD_EXPERIMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=8,
 };
 
-static WORD_EXPERIMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMS_CHILDREN),
+static WORD_EXPERIMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMS_CHILDREN),
     value: Some(&["experiments"]),
 };
 
-pub static WORD_EXPERIMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXPERIMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMN_CHILDREN),
+static WORD_EXPERIMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etal"),
@@ -146487,12 +146487,12 @@ pub static WORD_EXPERIMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_EXPERIMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMM_CHILDREN),
+static WORD_EXPERIMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ental"),
@@ -146524,12 +146524,12 @@ pub static WORD_EXPERIMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 3..=9,
 };
 
-static WORD_EXPERIMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMI_CHILDREN),
+static WORD_EXPERIMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -146563,12 +146563,12 @@ pub static WORD_EXPERIMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=8,
 };
 
-static WORD_EXPERIME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPERIME_CHILDREN),
+static WORD_EXPERIME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPERIME_CHILDREN),
     value: None,
 };
 
-static WORD_EXPERIME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPERIME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -146597,12 +146597,12 @@ static WORD_EXPERIME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXPERIMET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMET_CHILDREN),
+static WORD_EXPERIMET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMET_CHILDREN),
     value: Some(&["experiments", "experiment"]),
 };
 
-pub static WORD_EXPERIMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -146680,23 +146680,23 @@ pub static WORD_EXPERIMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictT
     range: 1..=9,
 };
 
-static WORD_EXPERIMER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMER_CHILDREN),
+static WORD_EXPERIMER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMER_CHILDREN),
     value: Some(&["experimenter"]),
 };
 
-pub static WORD_EXPERIMER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["experimenters"]],
     range: 1..=1,
 };
 
-static WORD_EXPERIMEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXPERIMEN_CHILDREN),
+static WORD_EXPERIMEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXPERIMEN_CHILDREN),
     value: Some(&["experiment"]),
 };
 
-static WORD_EXPERIMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXPERIMEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXPERIMENA_NODE),
     None,
     None,
@@ -146725,12 +146725,12 @@ static WORD_EXPERIMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] =
     None,
 ];
 
-static WORD_EXPERIMENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENT_CHILDREN),
+static WORD_EXPERIMENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aal"),
         dictgen::InsensitiveStr::Ascii("aally"),
@@ -146838,34 +146838,34 @@ pub static WORD_EXPERIMENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::Dict
     range: 1..=8,
 };
 
-static WORD_EXPERIMENS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENS_CHILDREN),
+static WORD_EXPERIMENS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENS_CHILDREN),
     value: Some(&["experiments"]),
 };
 
-pub static WORD_EXPERIMENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXPERIMENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENI_CHILDREN),
+static WORD_EXPERIMENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["experimenting"]],
     range: 2..=2,
 };
 
-static WORD_EXPERIMENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENE_CHILDREN),
+static WORD_EXPERIMENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -146883,12 +146883,12 @@ pub static WORD_EXPERIMENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::Dict
     range: 1..=3,
 };
 
-static WORD_EXPERIMENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENA_CHILDREN),
+static WORD_EXPERIMENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -146928,34 +146928,34 @@ pub static WORD_EXPERIMENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::Dict
     range: 1..=7,
 };
 
-static WORD_EXPERIMEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMEL_CHILDREN),
+static WORD_EXPERIMEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMEL_CHILDREN),
     value: Some(&["experimental"]),
 };
 
-pub static WORD_EXPERIMEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ly")],
     values: &[&["experimentally"]],
     range: 2..=2,
 };
 
-static WORD_EXPERIMED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMED_CHILDREN),
+static WORD_EXPERIMED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMED_CHILDREN),
     value: Some(&["experimented"]),
 };
 
-pub static WORD_EXPERIMED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXPERIMD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMD_CHILDREN),
+static WORD_EXPERIMD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("ntal"),
@@ -146987,12 +146987,12 @@ pub static WORD_EXPERIMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 2..=8,
 };
 
-static WORD_EXPERIMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMA_CHILDREN),
+static WORD_EXPERIMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -147080,12 +147080,12 @@ pub static WORD_EXPERIMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=10,
 };
 
-static WORD_EXPERIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIE_CHILDREN),
+static WORD_EXPERIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -147131,12 +147131,12 @@ pub static WORD_EXPERIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_EXPERIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIC_CHILDREN),
+static WORD_EXPERIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -147154,12 +147154,12 @@ pub static WORD_EXPERIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_EXPERIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIA_CHILDREN),
+static WORD_EXPERIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nce"),
         dictgen::InsensitiveStr::Ascii("nced"),
@@ -147185,12 +147185,12 @@ pub static WORD_EXPERIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=5,
 };
 
-static WORD_EXPERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERE_CHILDREN),
+static WORD_EXPERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icne"),
         dictgen::InsensitiveStr::Ascii("ience"),
@@ -147262,12 +147262,12 @@ pub static WORD_EXPERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_EXPERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERC_CHILDREN),
+static WORD_EXPERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -147283,12 +147283,12 @@ pub static WORD_EXPERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_EXPERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPERA_CHILDREN),
+static WORD_EXPERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mental"),
@@ -147324,12 +147324,12 @@ pub static WORD_EXPERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=10,
 };
 
-static WORD_EXPEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEP_CHILDREN),
+static WORD_EXPEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -147361,12 +147361,12 @@ pub static WORD_EXPEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEN_CHILDREN),
+static WORD_EXPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -147406,12 +147406,12 @@ pub static WORD_EXPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXPEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEM_CHILDREN),
+static WORD_EXPEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ental"),
@@ -147463,12 +147463,12 @@ pub static WORD_EXPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_EXPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEL_CHILDREN),
+static WORD_EXPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ls"),
@@ -147477,12 +147477,12 @@ pub static WORD_EXPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_EXPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEI_CHILDREN),
+static WORD_EXPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -147548,12 +147548,12 @@ pub static WORD_EXPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_EXPEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEE_CHILDREN),
+static WORD_EXPEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -147577,12 +147577,12 @@ pub static WORD_EXPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPED_CHILDREN),
+static WORD_EXPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etion"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -147604,12 +147604,12 @@ pub static WORD_EXPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EXPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPEC_CHILDREN),
+static WORD_EXPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atation"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -147675,12 +147675,12 @@ pub static WORD_EXPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_EXPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPC_CHILDREN),
+static WORD_EXPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eption"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -147712,12 +147712,12 @@ pub static WORD_EXPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_EXPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXPA_CHILDREN),
+static WORD_EXPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("lin"),
@@ -147785,12 +147785,12 @@ pub static WORD_EXPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXO_CHILDREN),
+static WORD_EXO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itcs"),
         dictgen::InsensitiveStr::Ascii("licit"),
@@ -147828,12 +147828,12 @@ pub static WORD_EXO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EXN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXN_CHILDREN),
+static WORD_EXN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ternal"),
         dictgen::InsensitiveStr::Ascii("ternalities"),
@@ -147851,12 +147851,12 @@ pub static WORD_EXN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_EXM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXM_CHILDREN),
+static WORD_EXM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aine"),
         dictgen::InsensitiveStr::Ascii("ained"),
@@ -147882,12 +147882,12 @@ pub static WORD_EXM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_EXL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXL_CHILDREN),
+static WORD_EXL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amation"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -147963,12 +147963,12 @@ pub static WORD_EXL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_EXI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXI_CHILDREN),
+static WORD_EXI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXI_CHILDREN),
     value: None,
 };
 
-static WORD_EXI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_EXIB_NODE),
     Some(&WORD_EXIC_NODE),
@@ -147997,12 +147997,12 @@ static WORD_EXI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXIX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIX_CHILDREN),
+static WORD_EXIX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("st"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -148013,12 +148013,12 @@ pub static WORD_EXIX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_EXIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIT_CHILDREN),
+static WORD_EXIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -148046,12 +148046,12 @@ pub static WORD_EXIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIS_CHILDREN),
+static WORD_EXIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -148129,12 +148129,12 @@ pub static WORD_EXIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIP_CHILDREN),
+static WORD_EXIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ration"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -148145,23 +148145,23 @@ pub static WORD_EXIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIN_CHILDREN),
+static WORD_EXIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ct")],
     values: &[&["extinct"]],
     range: 2..=2,
 };
 
-static WORD_EXIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIL_CHILDREN),
+static WORD_EXIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erate"),
         dictgen::InsensitiveStr::Ascii("erated"),
@@ -148177,12 +148177,12 @@ pub static WORD_EXIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_EXIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIC_CHILDREN),
+static WORD_EXIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ted"),
         dictgen::InsensitiveStr::Ascii("tement"),
@@ -148206,12 +148206,12 @@ pub static WORD_EXIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EXIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXIB_CHILDREN),
+static WORD_EXIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("itions"),
@@ -148220,12 +148220,12 @@ pub static WORD_EXIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_EXH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXH_CHILDREN),
+static WORD_EXH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alted"),
         dictgen::InsensitiveStr::Ascii("ange"),
@@ -148317,12 +148317,12 @@ pub static WORD_EXH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_EXE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXE_CHILDREN),
+static WORD_EXE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXE_CHILDREN),
     value: None,
 };
 
-static WORD_EXE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXEC_NODE),
@@ -148351,23 +148351,23 @@ static WORD_EXE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEX_CHILDREN),
+static WORD_EXEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utable")],
     values: &[&["executable"]],
     range: 6..=6,
 };
 
-static WORD_EXEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEU_CHILDREN),
+static WORD_EXEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cte"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -148393,23 +148393,23 @@ pub static WORD_EXEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EXES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXES_CHILDREN),
+static WORD_EXES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXES_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sive")],
     values: &[&["excessive"]],
     range: 4..=4,
 };
 
-static WORD_EXER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXER_CHILDREN),
+static WORD_EXER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXER_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bate"),
         dictgen::InsensitiveStr::Ascii("bated"),
@@ -148489,23 +148489,23 @@ pub static WORD_EXER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEQ_CHILDREN),
+static WORD_EXEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ution")],
     values: &[&["execution"]],
     range: 5..=5,
 };
 
-static WORD_EXEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEP_CHILDREN),
+static WORD_EXEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -148549,12 +148549,12 @@ pub static WORD_EXEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_EXEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEN_CHILDREN),
+static WORD_EXEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -148572,12 +148572,12 @@ pub static WORD_EXEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEM_CHILDREN),
+static WORD_EXEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pel"),
         dictgen::InsensitiveStr::Ascii("pels"),
@@ -148588,12 +148588,12 @@ pub static WORD_EXEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EXEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEL_CHILDREN),
+static WORD_EXEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("lent"),
@@ -148602,12 +148602,12 @@ pub static WORD_EXEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EXEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEG_CHILDREN),
+static WORD_EXEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gerating"),
         dictgen::InsensitiveStr::Ascii("geration"),
@@ -148616,12 +148616,12 @@ pub static WORD_EXEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=8,
 };
 
-static WORD_EXEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXEE_CHILDREN),
+static WORD_EXEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cutable"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -148641,12 +148641,12 @@ pub static WORD_EXEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXEC_CHILDREN),
+static WORD_EXEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXEC_CHILDREN),
     value: None,
 };
 
-static WORD_EXEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -148675,12 +148675,12 @@ static WORD_EXEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXECU_CHILDREN),
+static WORD_EXECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXECU_CHILDREN),
     value: None,
 };
 
-static WORD_EXECU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXECU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXECUA_NODE),
     Some(&WORD_EXECUB_NODE),
     Some(&WORD_EXECUC_NODE),
@@ -148709,12 +148709,12 @@ static WORD_EXECU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXECUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXECUT_CHILDREN),
+static WORD_EXECUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXECUT_CHILDREN),
     value: Some(&["execute"]),
 };
 
-static WORD_EXECUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXECUT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXECUTA_NODE),
     Some(&WORD_EXECUTB_NODE),
     None,
@@ -148743,12 +148743,12 @@ static WORD_EXECUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXECUTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTU_CHILDREN),
+static WORD_EXECUTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -148792,12 +148792,12 @@ pub static WORD_EXECUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_EXECUTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTT_CHILDREN),
+static WORD_EXECUTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -148807,23 +148807,23 @@ pub static WORD_EXECUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_EXECUTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTS_CHILDREN),
+static WORD_EXECUTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTS_CHILDREN),
     value: Some(&["executes"]),
 };
 
-pub static WORD_EXECUTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EXECUTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTR_CHILDREN),
+static WORD_EXECUTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -148833,34 +148833,34 @@ pub static WORD_EXECUTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=2,
 };
 
-static WORD_EXECUTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTO_CHILDREN),
+static WORD_EXECUTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("n")],
     values: &[&["execution"]],
     range: 1..=1,
 };
 
-static WORD_EXECUTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTN_CHILDREN),
+static WORD_EXECUTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["executing"]],
     range: 1..=1,
 };
 
-static WORD_EXECUTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTI_CHILDREN),
+static WORD_EXECUTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -148902,12 +148902,12 @@ pub static WORD_EXECUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_EXECUTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTE_CHILDREN),
+static WORD_EXECUTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -148916,23 +148916,23 @@ pub static WORD_EXECUTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=5,
 };
 
-static WORD_EXECUTD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTD_CHILDREN),
+static WORD_EXECUTD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTD_CHILDREN),
     value: Some(&["executed"]),
 };
 
-pub static WORD_EXECUTD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["executing"]],
     range: 3..=3,
 };
 
-static WORD_EXECUTB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTB_CHILDREN),
+static WORD_EXECUTB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -148948,12 +148948,12 @@ pub static WORD_EXECUTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_EXECUTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUTA_CHILDREN),
+static WORD_EXECUTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bable"),
         dictgen::InsensitiveStr::Ascii("bables"),
@@ -148991,12 +148991,12 @@ pub static WORD_EXECUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_EXECUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUS_CHILDREN),
+static WORD_EXECUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149020,12 +149020,12 @@ pub static WORD_EXECUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_EXECUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUR_CHILDREN),
+static WORD_EXECUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -149043,12 +149043,12 @@ pub static WORD_EXECUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_EXECUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUN_CHILDREN),
+static WORD_EXECUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149059,12 +149059,12 @@ pub static WORD_EXECUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_EXECUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUL_CHILDREN),
+static WORD_EXECUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atble"),
         dictgen::InsensitiveStr::Ascii("atbles"),
@@ -149082,12 +149082,12 @@ pub static WORD_EXECUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_EXECUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUI_CHILDREN),
+static WORD_EXECUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -149117,12 +149117,12 @@ pub static WORD_EXECUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_EXECUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUE_CHILDREN),
+static WORD_EXECUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUE_CHILDREN),
     value: Some(&["execute"]),
 };
 
-pub static WORD_EXECUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -149148,12 +149148,12 @@ pub static WORD_EXECUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_EXECUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUD_CHILDREN),
+static WORD_EXECUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149169,12 +149169,12 @@ pub static WORD_EXECUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_EXECUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUC_CHILDREN),
+static WORD_EXECUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("te"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -149196,12 +149196,12 @@ pub static WORD_EXECUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_EXECUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUB_CHILDREN),
+static WORD_EXECUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("ales"),
@@ -149210,12 +149210,12 @@ pub static WORD_EXECUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_EXECUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECUA_CHILDREN),
+static WORD_EXECUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bles"),
@@ -149245,12 +149245,12 @@ pub static WORD_EXECUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_EXECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECT_CHILDREN),
+static WORD_EXECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149314,12 +149314,12 @@ pub static WORD_EXECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXECP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECP_CHILDREN),
+static WORD_EXECP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -149335,12 +149335,12 @@ pub static WORD_EXECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECI_CHILDREN),
+static WORD_EXECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -149360,12 +149360,12 @@ pub static WORD_EXECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXECE_CHILDREN),
+static WORD_EXECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cutable"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -149387,23 +149387,23 @@ pub static WORD_EXECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXD_CHILDREN),
+static WORD_EXD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cutive")],
     values: &[&["executive"]],
     range: 6..=6,
 };
 
-static WORD_EXC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXC_CHILDREN),
+static WORD_EXC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXC_CHILDREN),
     value: None,
 };
 
-static WORD_EXC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EXCA_NODE),
     None,
     Some(&WORD_EXCC_NODE),
@@ -149432,12 +149432,12 @@ static WORD_EXC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCU_CHILDREN),
+static WORD_EXCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lde"),
         dictgen::InsensitiveStr::Ascii("lded"),
@@ -149483,12 +149483,12 @@ pub static WORD_EXCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_EXCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCT_CHILDREN),
+static WORD_EXCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acted"),
         dictgen::InsensitiveStr::Ascii("ract"),
@@ -149512,12 +149512,12 @@ pub static WORD_EXCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_EXCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCR_CHILDREN),
+static WORD_EXCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("ept"),
@@ -149533,12 +149533,12 @@ pub static WORD_EXCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_EXCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCP_CHILDREN),
+static WORD_EXCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -149576,23 +149576,23 @@ pub static WORD_EXCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCO_CHILDREN),
+static WORD_EXCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rciating")],
     values: &[&["excruciating"]],
     range: 8..=8,
 };
 
-static WORD_EXCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCL_CHILDREN),
+static WORD_EXCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amacion"),
         dictgen::InsensitiveStr::Ascii("amanation"),
@@ -149694,12 +149694,12 @@ pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCI_CHILDREN),
+static WORD_EXCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -149729,12 +149729,12 @@ pub static WORD_EXCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCH_CHILDREN),
+static WORD_EXCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("aged"),
@@ -149844,12 +149844,12 @@ pub static WORD_EXCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXCE_CHILDREN),
+static WORD_EXCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXCE_CHILDREN),
     value: None,
 };
 
-static WORD_EXCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXCE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXCEC_NODE),
@@ -149878,12 +149878,12 @@ static WORD_EXCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXCEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEW_CHILDREN),
+static WORD_EXCEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ption"),
         dictgen::InsensitiveStr::Ascii("ptional"),
@@ -149893,12 +149893,12 @@ pub static WORD_EXCEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_EXCEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEU_CHILDREN),
+static WORD_EXCEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctable"),
         dictgen::InsensitiveStr::Ascii("ctables"),
@@ -149956,12 +149956,12 @@ pub static WORD_EXCEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXCET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCET_CHILDREN),
+static WORD_EXCET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCET_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -150013,12 +150013,12 @@ pub static WORD_EXCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXCES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCES_CHILDREN),
+static WORD_EXCES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCES_CHILDREN),
     value: Some(&["excess"]),
 };
 
-pub static WORD_EXCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -150042,12 +150042,12 @@ pub static WORD_EXCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXCER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCER_CHILDREN),
+static WORD_EXCER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCER_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cise"),
         dictgen::InsensitiveStr::Ascii("cised"),
@@ -150085,12 +150085,12 @@ pub static WORD_EXCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXCEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEP_CHILDREN),
+static WORD_EXCEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cional"),
         dictgen::InsensitiveStr::Ascii("etion"),
@@ -150144,12 +150144,12 @@ pub static WORD_EXCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXCEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEO_CHILDREN),
+static WORD_EXCEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pted"),
@@ -150167,12 +150167,12 @@ pub static WORD_EXCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXCEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEN_CHILDREN),
+static WORD_EXCEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tric"),
         dictgen::InsensitiveStr::Ascii("tricity"),
@@ -150182,12 +150182,12 @@ pub static WORD_EXCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_EXCEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEM_CHILDREN),
+static WORD_EXCEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pted"),
@@ -150205,12 +150205,12 @@ pub static WORD_EXCEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EXCEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEL_CHILDREN),
+static WORD_EXCEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("erates"),
@@ -150234,12 +150234,12 @@ pub static WORD_EXCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EXCEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEI_CHILDREN),
+static WORD_EXCEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rpt"),
         dictgen::InsensitiveStr::Ascii("rpts"),
@@ -150248,12 +150248,12 @@ pub static WORD_EXCEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EXCEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEE_CHILDREN),
+static WORD_EXCEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("digly"),
         dictgen::InsensitiveStr::Ascii("dinly"),
@@ -150271,12 +150271,12 @@ pub static WORD_EXCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EXCED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCED_CHILDREN),
+static WORD_EXCED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCED_CHILDREN),
     value: Some(&["exceed"]),
 };
 
-pub static WORD_EXCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -150300,12 +150300,12 @@ pub static WORD_EXCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_EXCEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCEC_CHILDREN),
+static WORD_EXCEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ise"),
         dictgen::InsensitiveStr::Ascii("ised"),
@@ -150385,12 +150385,12 @@ pub static WORD_EXCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCC_CHILDREN),
+static WORD_EXCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eds"),
         dictgen::InsensitiveStr::Ascii("ute"),
@@ -150399,12 +150399,12 @@ pub static WORD_EXCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_EXCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXCA_CHILDREN),
+static WORD_EXCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctly"),
@@ -150438,12 +150438,12 @@ pub static WORD_EXCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EXA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EXA_CHILDREN),
+static WORD_EXA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EXA_CHILDREN),
     value: None,
 };
 
-static WORD_EXA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EXA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EXAC_NODE),
@@ -150472,12 +150472,12 @@ static WORD_EXA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EXAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAU_CHILDREN),
+static WORD_EXAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hsted"),
         dictgen::InsensitiveStr::Ascii("hsting"),
@@ -150497,12 +150497,12 @@ pub static WORD_EXAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_EXAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAT_CHILDREN),
+static WORD_EXAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAT_CHILDREN),
     value: Some(&["exact"]),
 };
 
-pub static WORD_EXAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cly"),
         dictgen::InsensitiveStr::Ascii("ctly"),
@@ -150520,23 +150520,23 @@ pub static WORD_EXAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_EXAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAR_CHILDREN),
+static WORD_EXAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cebated")],
     values: &[&["exacerbated"]],
     range: 7..=7,
 };
 
-static WORD_EXAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAP_CHILDREN),
+static WORD_EXAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anded"),
         dictgen::InsensitiveStr::Ascii("anding"),
@@ -150586,12 +150586,12 @@ pub static WORD_EXAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EXAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAN_CHILDREN),
+static WORD_EXAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -150601,12 +150601,12 @@ pub static WORD_EXAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_EXAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAM_CHILDREN),
+static WORD_EXAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eple"),
         dictgen::InsensitiveStr::Ascii("eples"),
@@ -150670,12 +150670,12 @@ pub static WORD_EXAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EXAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAH_CHILDREN),
+static WORD_EXAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ust"),
         dictgen::InsensitiveStr::Ascii("usted"),
@@ -150691,12 +150691,12 @@ pub static WORD_EXAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_EXAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAG_CHILDREN),
+static WORD_EXAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erate"),
         dictgen::InsensitiveStr::Ascii("erated"),
@@ -150750,12 +150750,12 @@ pub static WORD_EXAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_EXAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EXAC_CHILDREN),
+static WORD_EXAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EXAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EXAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EXAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arbated"),
         dictgen::InsensitiveStr::Ascii("berate"),
@@ -150779,12 +150779,12 @@ pub static WORD_EXAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EW_CHILDREN),
+static WORD_EW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EW_CHILDREN),
     value: None,
 };
 
-pub static WORD_EW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hwer"),
         dictgen::InsensitiveStr::Ascii("xception"),
@@ -150793,12 +150793,12 @@ pub static WORD_EW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_EV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EV_CHILDREN),
+static WORD_EV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EV_CHILDREN),
     value: None,
 };
 
-static WORD_EV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EVA_NODE),
     None,
     None,
@@ -150827,23 +150827,23 @@ static WORD_EV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EVY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVY_CHILDREN),
+static WORD_EVY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVY_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rthing")],
     values: &[&["everything"]],
     range: 6..=6,
 };
 
-static WORD_EVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVR_CHILDREN),
+static WORD_EVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eyones"),
         dictgen::InsensitiveStr::Ascii("eytime"),
@@ -150867,12 +150867,12 @@ pub static WORD_EVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_EVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVO_CHILDREN),
+static WORD_EVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("luate"),
         dictgen::InsensitiveStr::Ascii("luated"),
@@ -150910,12 +150910,12 @@ pub static WORD_EVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_EVN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVN_CHILDREN),
+static WORD_EVN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVN_CHILDREN),
     value: Some(&["even"]),
 };
 
-pub static WORD_EVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -150925,12 +150925,12 @@ pub static WORD_EVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_EVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVL_CHILDREN),
+static WORD_EVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oved"),
         dictgen::InsensitiveStr::Ascii("oves"),
@@ -150962,12 +150962,12 @@ pub static WORD_EVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_EVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVI_CHILDREN),
+static WORD_EVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("citon"),
@@ -151001,12 +151001,12 @@ pub static WORD_EVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EVE_CHILDREN),
+static WORD_EVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EVE_CHILDREN),
     value: None,
 };
 
-static WORD_EVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EVE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -151035,12 +151035,12 @@ static WORD_EVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EVEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEY_CHILDREN),
+static WORD_EVEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEY_CHILDREN),
     value: Some(&["every"]),
 };
 
-pub static WORD_EVEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("one"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -151058,23 +151058,23 @@ pub static WORD_EVEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_EVET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVET_CHILDREN),
+static WORD_EVET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVET_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ually")],
     values: &[&["eventually"]],
     range: 5..=5,
 };
 
-static WORD_EVES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVES_CHILDREN),
+static WORD_EVES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVES_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("drop"),
         dictgen::InsensitiveStr::Ascii("dropped"),
@@ -151092,12 +151092,12 @@ pub static WORD_EVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_EVER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVER_CHILDREN),
+static WORD_EVER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVER_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("aged"),
@@ -151171,12 +151171,12 @@ pub static WORD_EVER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EVEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEO_CHILDREN),
+static WORD_EVEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lution"),
         dictgen::InsensitiveStr::Ascii("lutionary"),
@@ -151196,12 +151196,12 @@ pub static WORD_EVEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_EVEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEN_CHILDREN),
+static WORD_EVEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("galical"),
         dictgen::InsensitiveStr::Ascii("htually"),
@@ -151229,23 +151229,23 @@ pub static WORD_EVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_EVEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEM_CHILDREN),
+static WORD_EVEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEM_CHILDREN),
     value: Some(&["even", "ever"]),
 };
 
-pub static WORD_EVEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EVEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEL_CHILDREN),
+static WORD_EVEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ope"),
@@ -151275,12 +151275,12 @@ pub static WORD_EVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_EVEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVEI_CHILDREN),
+static WORD_EVEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dence"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -151289,12 +151289,12 @@ pub static WORD_EVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EVA_CHILDREN),
+static WORD_EVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilable"),
         dictgen::InsensitiveStr::Ascii("lation"),
@@ -151424,12 +151424,12 @@ pub static WORD_EVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_EU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EU_CHILDREN),
+static WORD_EU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clidian"),
         dictgen::InsensitiveStr::Ascii("gencis"),
@@ -151505,12 +151505,12 @@ pub static WORD_EU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_ET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ET_CHILDREN),
+static WORD_ET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ET_CHILDREN),
     value: None,
 };
 
-pub static WORD_ET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ablish"),
         dictgen::InsensitiveStr::Ascii("ablishd"),
@@ -151622,12 +151622,12 @@ pub static WORD_ET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_ES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ES_CHILDREN),
+static WORD_ES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ES_CHILDREN),
     value: None,
 };
 
-static WORD_ES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ESA_NODE),
     None,
     Some(&WORD_ESC_NODE),
@@ -151656,23 +151656,23 @@ static WORD_ES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ESY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESY_CHILDREN),
+static WORD_ESY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESY_CHILDREN),
     value: Some(&["easy"]),
 };
 
-pub static WORD_ESY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ESU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESU_CHILDREN),
+static WORD_ESU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("do"),
         dictgen::InsensitiveStr::Ascii("mption"),
@@ -151681,12 +151681,12 @@ pub static WORD_ESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_EST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EST_CHILDREN),
+static WORD_EST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EST_CHILDREN),
     value: None,
 };
 
-pub static WORD_EST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abilish"),
         dictgen::InsensitiveStr::Ascii("abilshment"),
@@ -151762,12 +151762,12 @@ pub static WORD_EST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=10,
 };
 
-static WORD_ESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESS_CHILDREN),
+static WORD_ESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eintially"),
         dictgen::InsensitiveStr::Ascii("encial"),
@@ -151833,12 +151833,12 @@ pub static WORD_ESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ESP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESP_CHILDREN),
+static WORD_ESP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acally"),
         dictgen::InsensitiveStr::Ascii("ace"),
@@ -151918,23 +151918,23 @@ pub static WORD_ESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ESO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESO_CHILDREN),
+static WORD_ESO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("terisch")],
     values: &[&["esoteric"]],
     range: 7..=7,
 };
 
-static WORD_ESN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESN_CHILDREN),
+static WORD_ESN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ure"),
         dictgen::InsensitiveStr::Ascii("ured"),
@@ -151944,12 +151944,12 @@ pub static WORD_ESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_ESL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESL_CHILDREN),
+static WORD_ESL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ewhere"),
@@ -151958,12 +151958,12 @@ pub static WORD_ESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ESI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESI_CHILDREN),
+static WORD_ESI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("ly"),
@@ -152009,12 +152009,12 @@ pub static WORD_ESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ESG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESG_CHILDREN),
+static WORD_ESG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -152026,12 +152026,12 @@ pub static WORD_ESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_ESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESE_CHILDREN),
+static WORD_ESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cute"),
         dictgen::InsensitiveStr::Ascii("ntial"),
@@ -152041,12 +152041,12 @@ pub static WORD_ESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_ESC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESC_CHILDREN),
+static WORD_ESC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alatie"),
         dictgen::InsensitiveStr::Ascii("alatin"),
@@ -152124,12 +152124,12 @@ pub static WORD_ESC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ESA_CHILDREN),
+static WORD_ESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cape"),
         dictgen::InsensitiveStr::Ascii("cpe"),
@@ -152140,12 +152140,12 @@ pub static WORD_ESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_ER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ER_CHILDREN),
+static WORD_ER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ER_CHILDREN),
     value: None,
 };
 
-static WORD_ER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ERA_NODE),
     None,
     None,
@@ -152174,12 +152174,12 @@ static WORD_ER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERV_CHILDREN),
+static WORD_ERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ery"),
         dictgen::InsensitiveStr::Ascii("erything"),
@@ -152189,12 +152189,12 @@ pub static WORD_ERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERT_CHILDREN),
+static WORD_ERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oneous"),
         dictgen::InsensitiveStr::Ascii("oneously"),
@@ -152210,12 +152210,12 @@ pub static WORD_ERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERR_CHILDREN),
+static WORD_ERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aneously"),
         dictgen::InsensitiveStr::Ascii("aticly"),
@@ -152287,23 +152287,23 @@ pub static WORD_ERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ERQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERQ_CHILDREN),
+static WORD_ERQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uest")],
     values: &[&["request"]],
     range: 4..=4,
 };
 
-static WORD_ERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERO_CHILDREN),
+static WORD_ERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("neous"),
         dictgen::InsensitiveStr::Ascii("niously"),
@@ -152327,12 +152327,12 @@ pub static WORD_ERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERM_CHILDREN),
+static WORD_ERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ergency"),
         dictgen::InsensitiveStr::Ascii("inated"),
@@ -152342,12 +152342,12 @@ pub static WORD_ERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_ERL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERL_CHILDREN),
+static WORD_ERL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iear"),
         dictgen::InsensitiveStr::Ascii("ier"),
@@ -152357,34 +152357,34 @@ pub static WORD_ERL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_ERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERF_CHILDREN),
+static WORD_ERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ormance")],
     values: &[&["performance"]],
     range: 7..=7,
 };
 
-static WORD_ERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERE_CHILDREN),
+static WORD_ERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sted")],
     values: &[&["arrested", "erected"]],
     range: 4..=4,
 };
 
-static WORD_ERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ERA_CHILDREN),
+static WORD_ERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ised"),
         dictgen::InsensitiveStr::Ascii("lier"),
@@ -152408,12 +152408,12 @@ pub static WORD_ERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_EQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EQ_CHILDREN),
+static WORD_EQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EQ_CHILDREN),
     value: None,
 };
 
-static WORD_EQ_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EQ_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EQA_NODE),
     None,
     None,
@@ -152442,12 +152442,12 @@ static WORD_EQ_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EQU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EQU_CHILDREN),
+static WORD_EQU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EQU_CHILDREN),
     value: None,
 };
 
-static WORD_EQU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EQU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EQUA_NODE),
     None,
     None,
@@ -152476,12 +152476,12 @@ static WORD_EQU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EQUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUV_CHILDREN),
+static WORD_EQUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alent"),
         dictgen::InsensitiveStr::Ascii("ilent"),
@@ -152491,23 +152491,23 @@ pub static WORD_EQUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_EQUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUU_CHILDREN),
+static WORD_EQUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ivalence")],
     values: &[&["equivalence"]],
     range: 8..=8,
 };
 
-static WORD_EQUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUT_CHILDREN),
+static WORD_EQUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -152516,23 +152516,23 @@ pub static WORD_EQUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_EQUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUL_CHILDREN),
+static WORD_EQUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUL_CHILDREN),
     value: Some(&["equal"]),
 };
 
-pub static WORD_EQUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_EQUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EQUI_CHILDREN),
+static WORD_EQUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EQUI_CHILDREN),
     value: None,
 };
 
-static WORD_EQUI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EQUI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EQUIA_NODE),
     None,
     None,
@@ -152561,12 +152561,12 @@ static WORD_EQUI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EQUIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIV_CHILDREN),
+static WORD_EQUIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alalent"),
         dictgen::InsensitiveStr::Ascii("alance"),
@@ -152646,34 +152646,34 @@ pub static WORD_EQUIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_EQUIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIT_CHILDREN),
+static WORD_EQUIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orial")],
     values: &[&["equatorial"]],
     range: 5..=5,
 };
 
-static WORD_EQUIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIR_CHILDREN),
+static WORD_EQUIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["require", "enquire", "equine", "esquire"]],
     range: 1..=1,
 };
 
-static WORD_EQUIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIP_CHILDREN),
+static WORD_EQUIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ement"),
@@ -152695,23 +152695,23 @@ pub static WORD_EQUIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_EQUIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIM_CHILDREN),
+static WORD_EQUIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ent")],
     values: &[&["equipment"]],
     range: 3..=3,
 };
 
-static WORD_EQUIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIL_CHILDREN),
+static WORD_EQUIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIL_CHILDREN),
     value: Some(&["equal"]),
 };
 
-pub static WORD_EQUIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avalent"),
         dictgen::InsensitiveStr::Ascii("avent"),
@@ -152747,23 +152747,23 @@ pub static WORD_EQUIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_EQUIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIE_CHILDREN),
+static WORD_EQUIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("valent")],
     values: &[&["equivalent"]],
     range: 6..=6,
 };
 
-static WORD_EQUIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUIA_CHILDREN),
+static WORD_EQUIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lent"),
         dictgen::InsensitiveStr::Ascii("vlent"),
@@ -152772,12 +152772,12 @@ pub static WORD_EQUIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_EQUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUE_CHILDREN),
+static WORD_EQUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -152795,12 +152795,12 @@ pub static WORD_EQUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EQUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQUA_CHILDREN),
+static WORD_EQUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilateral"),
         dictgen::InsensitiveStr::Ascii("ilty"),
@@ -152828,12 +152828,12 @@ pub static WORD_EQUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_EQI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQI_CHILDREN),
+static WORD_EQI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("valent"),
         dictgen::InsensitiveStr::Ascii("valents"),
@@ -152842,12 +152842,12 @@ pub static WORD_EQI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_EQA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EQA_CHILDREN),
+static WORD_EQA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EQA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EQA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EQA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ul"),
         dictgen::InsensitiveStr::Ascii("ulity"),
@@ -152865,12 +152865,12 @@ pub static WORD_EQA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_EP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EP_CHILDREN),
+static WORD_EP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EP_CHILDREN),
     value: None,
 };
 
-pub static WORD_EP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andable"),
         dictgen::InsensitiveStr::Ascii("ecifica"),
@@ -153002,12 +153002,12 @@ pub static WORD_EP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_EN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EN_CHILDREN),
+static WORD_EN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EN_CHILDREN),
     value: None,
 };
 
-static WORD_EN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENA_NODE),
     Some(&WORD_ENB_NODE),
     Some(&WORD_ENC_NODE),
@@ -153036,12 +153036,12 @@ static WORD_EN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENY_CHILDREN),
+static WORD_ENY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thing"),
         dictgen::InsensitiveStr::Ascii("way"),
@@ -153050,23 +153050,23 @@ pub static WORD_ENY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ENX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENX_CHILDREN),
+static WORD_ENX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENX_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["next"]],
     range: 1..=1,
 };
 
-static WORD_ENV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENV_CHILDREN),
+static WORD_ENV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENV_CHILDREN),
     value: None,
 };
 
-static WORD_ENV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENVA_NODE),
     None,
     None,
@@ -153095,23 +153095,23 @@ static WORD_ENV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENVV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVV_CHILDREN),
+static WORD_ENVV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ironment")],
     values: &[&["environment"]],
     range: 8..=8,
 };
 
-static WORD_ENVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVR_CHILDREN),
+static WORD_ENVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ionment"),
@@ -153143,12 +153143,12 @@ pub static WORD_ENVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_ENVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVO_CHILDREN),
+static WORD_ENVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ke"),
         dictgen::InsensitiveStr::Ascii("ked"),
@@ -153174,12 +153174,12 @@ pub static WORD_ENVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ENVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVL_CHILDREN),
+static WORD_ENVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eope"),
         dictgen::InsensitiveStr::Ascii("ope"),
@@ -153188,12 +153188,12 @@ pub static WORD_ENVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ENVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENVI_CHILDREN),
+static WORD_ENVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENVI_CHILDREN),
     value: None,
 };
 
-static WORD_ENVI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENVI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -153222,12 +153222,12 @@ static WORD_ENVI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENVIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVIR_CHILDREN),
+static WORD_ENVIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eonment"),
         dictgen::InsensitiveStr::Ascii("ionment"),
@@ -153329,12 +153329,12 @@ pub static WORD_ENVIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_ENVIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVIO_CHILDREN),
+static WORD_ENVIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mental"),
@@ -153398,12 +153398,12 @@ pub static WORD_ENVIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_ENVIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVIN_CHILDREN),
+static WORD_ENVIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("roment"),
         dictgen::InsensitiveStr::Ascii("ronment"),
@@ -153413,23 +153413,23 @@ pub static WORD_ENVIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_ENVID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVID_CHILDREN),
+static WORD_ENVID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVID_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enced")],
     values: &[&["evidenced"]],
     range: 5..=5,
 };
 
-static WORD_ENVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVE_CHILDREN),
+static WORD_ENVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("loppe"),
         dictgen::InsensitiveStr::Ascii("lopped"),
@@ -153449,23 +153449,23 @@ pub static WORD_ENVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ENVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENVA_CHILDREN),
+static WORD_ENVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("luation")],
     values: &[&["evaluation"]],
     range: 7..=7,
 };
 
-static WORD_ENU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENU_CHILDREN),
+static WORD_ENU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("lation"),
@@ -153533,12 +153533,12 @@ pub static WORD_ENU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENT_CHILDREN),
+static WORD_ENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENT_CHILDREN),
     value: None,
 };
 
-static WORD_ENT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENTA_NODE),
     Some(&WORD_ENTB_NODE),
     None,
@@ -153567,23 +153567,23 @@ static WORD_ENT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENTY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTY_CHILDREN),
+static WORD_ENTY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTY_CHILDREN),
     value: Some(&["entry", "entity"]),
 };
 
-pub static WORD_ENTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ENTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTU_CHILDREN),
+static WORD_ENTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("siastic"),
         dictgen::InsensitiveStr::Ascii("siastically"),
@@ -153592,12 +153592,12 @@ pub static WORD_ENTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=11,
 };
 
-static WORD_ENTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTT_CHILDREN),
+static WORD_ENTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ries"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -153606,12 +153606,12 @@ pub static WORD_ENTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ENTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTR_CHILDREN),
+static WORD_ENTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -153705,12 +153705,12 @@ pub static WORD_ENTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_ENTQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTQ_CHILDREN),
+static WORD_ENTQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uire"),
         dictgen::InsensitiveStr::Ascii("uired"),
@@ -153728,12 +153728,12 @@ pub static WORD_ENTQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ENTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTO_CHILDREN),
+static WORD_ENTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rpy"),
         dictgen::InsensitiveStr::Ascii("ties"),
@@ -153744,12 +153744,12 @@ pub static WORD_ENTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ENTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTI_CHILDREN),
+static WORD_ENTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erly"),
         dictgen::InsensitiveStr::Ascii("erty"),
@@ -153815,12 +153815,12 @@ pub static WORD_ENTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ENTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTH_CHILDREN),
+static WORD_ENTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aplies"),
         dictgen::InsensitiveStr::Ascii("aply"),
@@ -153900,12 +153900,12 @@ pub static WORD_ENTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_ENTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTE_CHILDREN),
+static WORD_ENTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("nded"),
@@ -153995,23 +153995,23 @@ pub static WORD_ENTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ENTB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTB_CHILDREN),
+static WORD_ENTB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ook")],
     values: &[&["netbook"]],
     range: 3..=3,
 };
 
-static WORD_ENTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENTA_CHILDREN),
+static WORD_ENTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("glements"),
         dictgen::InsensitiveStr::Ascii("rtaining"),
@@ -154021,12 +154021,12 @@ pub static WORD_ENTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_ENS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENS_CHILDREN),
+static WORD_ENS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alve"),
         dictgen::InsensitiveStr::Ascii("alved"),
@@ -154046,12 +154046,12 @@ pub static WORD_ENS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ENR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENR_CHILDREN),
+static WORD_ENR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gy"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -154083,12 +154083,12 @@ pub static WORD_ENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ENQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENQ_CHILDREN),
+static WORD_ENQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ue"),
         dictgen::InsensitiveStr::Ascii("ueing"),
@@ -154098,12 +154098,12 @@ pub static WORD_ENQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ENP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENP_CHILDREN),
+static WORD_ENP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("doint"),
         dictgen::InsensitiveStr::Ascii("doints"),
@@ -154121,12 +154121,12 @@ pub static WORD_ENP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENO_CHILDREN),
+static WORD_ENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cde"),
         dictgen::InsensitiveStr::Ascii("cded"),
@@ -154220,12 +154220,12 @@ pub static WORD_ENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENN_CHILDREN),
+static WORD_ENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emies"),
         dictgen::InsensitiveStr::Ascii("point"),
@@ -154236,12 +154236,12 @@ pub static WORD_ENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_ENM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENM_CHILDREN),
+static WORD_ENM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pty"),
         dictgen::InsensitiveStr::Ascii("um"),
@@ -154259,12 +154259,12 @@ pub static WORD_ENM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_ENL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENL_CHILDREN),
+static WORD_ENL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("argment"),
         dictgen::InsensitiveStr::Ascii("argments"),
@@ -154320,23 +154320,23 @@ pub static WORD_ENL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ENJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENJ_CHILDREN),
+static WORD_ENJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oing")],
     values: &[&["enjoying"]],
     range: 4..=4,
 };
 
-static WORD_ENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENI_CHILDREN),
+static WORD_ENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gneer"),
         dictgen::InsensitiveStr::Ascii("ronment"),
@@ -154372,12 +154372,12 @@ pub static WORD_ENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_ENH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENH_CHILDREN),
+static WORD_ENH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abce"),
         dictgen::InsensitiveStr::Ascii("abced"),
@@ -154439,12 +154439,12 @@ pub static WORD_ENH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ENG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENG_CHILDREN),
+static WORD_ENG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agaments"),
         dictgen::InsensitiveStr::Ascii("agemet"),
@@ -154530,12 +154530,12 @@ pub static WORD_ENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENF_CHILDREN),
+static WORD_ENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lamed"),
         dictgen::InsensitiveStr::Ascii("orcable"),
@@ -154569,12 +154569,12 @@ pub static WORD_ENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENE_CHILDREN),
+static WORD_ENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("abled"),
@@ -154646,12 +154646,12 @@ pub static WORD_ENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_END_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_END_CHILDREN),
+static WORD_END_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_END_CHILDREN),
     value: None,
 };
 
-static WORD_END_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_END_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENDA_NODE),
     None,
     Some(&WORD_ENDC_NODE),
@@ -154680,12 +154680,12 @@ static WORD_END_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDU_CHILDREN),
+static WORD_ENDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -154703,23 +154703,23 @@ pub static WORD_ENDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ENDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDR_CHILDREN),
+static WORD_ENDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ose")],
     values: &[&["endorse"]],
     range: 3..=3,
 };
 
-static WORD_ENDP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDP_CHILDREN),
+static WORD_ENDP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("doint"),
         dictgen::InsensitiveStr::Ascii("doints"),
@@ -154747,12 +154747,12 @@ pub static WORD_ENDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ENDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDO_CHILDREN),
+static WORD_ENDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctrinated"),
         dictgen::InsensitiveStr::Ascii("ctrination"),
@@ -154784,23 +154784,23 @@ pub static WORD_ENDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ENDN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDN_CHILDREN),
+static WORD_ENDN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oden")],
     values: &[&["endnode"]],
     range: 4..=4,
 };
 
-static WORD_ENDL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDL_CHILDREN),
+static WORD_ENDL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essley"),
         dictgen::InsensitiveStr::Ascii("essy"),
@@ -154809,12 +154809,12 @@ pub static WORD_ENDL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ENDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDI_CHILDREN),
+static WORD_ENDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anes"),
         dictgen::InsensitiveStr::Ascii("aness"),
@@ -154846,34 +154846,34 @@ pub static WORD_ENDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ENDG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDG_CHILDREN),
+static WORD_ENDG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["edge", "end"]],
     range: 1..=1,
 };
 
-static WORD_ENDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDF_CHILDREN),
+static WORD_ENDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("i")],
     values: &[&["endif"]],
     range: 1..=1,
 };
 
-static WORD_ENDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDE_CHILDREN),
+static WORD_ENDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDE_CHILDREN),
     value: Some(&["end"]),
 };
 
-pub static WORD_ENDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ver"),
         dictgen::InsensitiveStr::Ascii("vered"),
@@ -154897,23 +154897,23 @@ pub static WORD_ENDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ENDD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDD_CHILDREN),
+static WORD_ENDD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["ending"]],
     range: 3..=3,
 };
 
-static WORD_ENDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDC_CHILDREN),
+static WORD_ENDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oded"),
         dictgen::InsensitiveStr::Ascii("oder"),
@@ -154933,12 +154933,12 @@ pub static WORD_ENDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ENDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENDA_CHILDREN),
+static WORD_ENDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gnering"),
         dictgen::InsensitiveStr::Ascii("ndering"),
@@ -154954,12 +154954,12 @@ pub static WORD_ENDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENC_CHILDREN),
+static WORD_ENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENC_CHILDREN),
     value: None,
 };
 
-static WORD_ENC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ENCA_NODE),
     None,
     None,
@@ -154988,12 +154988,12 @@ static WORD_ENC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENCY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCY_CHILDREN),
+static WORD_ENCY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clapedia"),
         dictgen::InsensitiveStr::Ascii("clepedia"),
@@ -155041,12 +155041,12 @@ pub static WORD_ENCY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ENCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCU_CHILDREN),
+static WORD_ENCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mberance"),
         dictgen::InsensitiveStr::Ascii("psulates"),
@@ -155055,12 +155055,12 @@ pub static WORD_ENCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=8,
 };
 
-static WORD_ENCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCR_CHILDREN),
+static WORD_ENCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cypt"),
         dictgen::InsensitiveStr::Ascii("cypted"),
@@ -155140,23 +155140,23 @@ pub static WORD_ENCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ENCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCP_CHILDREN),
+static WORD_ENCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rytion")],
     values: &[&["encryption"]],
     range: 6..=6,
 };
 
-static WORD_ENCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ENCO_CHILDREN),
+static WORD_ENCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ENCO_CHILDREN),
     value: None,
 };
 
-static WORD_ENCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ENCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_ENCOC_NODE),
@@ -155185,12 +155185,12 @@ static WORD_ENCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ENCOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOU_CHILDREN),
+static WORD_ENCOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nted"),
         dictgen::InsensitiveStr::Ascii("nteerd"),
@@ -155244,12 +155244,12 @@ pub static WORD_ENCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ENCOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOS_CHILDREN),
+static WORD_ENCOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -155273,12 +155273,12 @@ pub static WORD_ENCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ENCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOR_CHILDREN),
+static WORD_ENCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -155306,12 +155306,12 @@ pub static WORD_ENCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ENCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCON_CHILDREN),
+static WORD_ENCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -155333,12 +155333,12 @@ pub static WORD_ENCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ENCOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOM_CHILDREN),
+static WORD_ENCOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apsses"),
         dictgen::InsensitiveStr::Ascii("pas"),
@@ -155370,12 +155370,12 @@ pub static WORD_ENCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ENCOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOL_CHILDREN),
+static WORD_ENCOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sed"),
         dictgen::InsensitiveStr::Ascii("sure"),
@@ -155384,12 +155384,12 @@ pub static WORD_ENCOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ENCOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOD_CHILDREN),
+static WORD_ENCOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ingt"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -155400,12 +155400,12 @@ pub static WORD_ENCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ENCOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCOC_CHILDREN),
+static WORD_ENCOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -155427,12 +155427,12 @@ pub static WORD_ENCOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ENCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCL_CHILDREN),
+static WORD_ENCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("osng"),
         dictgen::InsensitiveStr::Ascii("osue"),
@@ -155456,23 +155456,23 @@ pub static WORD_ENCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ENCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCI_CHILDREN),
+static WORD_ENCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("clopedia")],
     values: &[&["encyclopedia"]],
     range: 8..=8,
 };
 
-static WORD_ENCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCH_CHILDREN),
+static WORD_ENCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amtment"),
         dictgen::InsensitiveStr::Ascii("anced"),
@@ -155522,23 +155522,23 @@ pub static WORD_ENCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_ENCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCE_CHILDREN),
+static WORD_ENCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("clopedia")],
     values: &[&["encyclopedia"]],
     range: 8..=8,
 };
 
-static WORD_ENCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENCA_CHILDREN),
+static WORD_ENCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hnt"),
         dictgen::InsensitiveStr::Ascii("hnting"),
@@ -155578,12 +155578,12 @@ pub static WORD_ENCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ENB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENB_CHILDREN),
+static WORD_ENB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("abled"),
@@ -155619,12 +155619,12 @@ pub static WORD_ENB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ENA_CHILDREN),
+static WORD_ENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -155668,12 +155668,12 @@ pub static WORD_ENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_EM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EM_CHILDREN),
+static WORD_EM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EM_CHILDREN),
     value: None,
 };
 
-static WORD_EM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EMA_NODE),
     Some(&WORD_EMB_NODE),
     Some(&WORD_EMC_NODE),
@@ -155702,12 +155702,12 @@ static WORD_EM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMU_CHILDREN),
+static WORD_EMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("altion"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -155729,12 +155729,12 @@ pub static WORD_EMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_EMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMT_CHILDREN),
+static WORD_EMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ies"),
@@ -155760,12 +155760,12 @@ pub static WORD_EMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_EMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EMP_CHILDREN),
+static WORD_EMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EMP_CHILDREN),
     value: None,
 };
 
-static WORD_EMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EMPA_NODE),
     None,
     None,
@@ -155794,34 +155794,34 @@ static WORD_EMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EMPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPY_CHILDREN),
+static WORD_EMPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPY_CHILDREN),
     value: Some(&["empty"]),
 };
 
-pub static WORD_EMPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ty")],
     values: &[&["empty"]],
     range: 2..=2,
 };
 
-static WORD_EMPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPU_CHILDREN),
+static WORD_EMPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["empty"]],
     range: 1..=1,
 };
 
-static WORD_EMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPT_CHILDREN),
+static WORD_EMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("niess"),
@@ -155841,12 +155841,12 @@ pub static WORD_EMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPR_CHILDREN),
+static WORD_EMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essed"),
         dictgen::InsensitiveStr::Ascii("essing"),
@@ -155882,12 +155882,12 @@ pub static WORD_EMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_EMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPO_CHILDREN),
+static WORD_EMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lyees"),
         dictgen::InsensitiveStr::Ascii("rer"),
@@ -155896,12 +155896,12 @@ pub static WORD_EMPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_EMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPL_CHILDREN),
+static WORD_EMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ore"),
         dictgen::InsensitiveStr::Ascii("oyeed"),
@@ -155941,12 +155941,12 @@ pub static WORD_EMPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_EMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPI_CHILDREN),
+static WORD_EMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("racally"),
@@ -155970,12 +155970,12 @@ pub static WORD_EMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_EMPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPH_CHILDREN),
+static WORD_EMPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acized"),
         dictgen::InsensitiveStr::Ascii("acizing"),
@@ -156031,12 +156031,12 @@ pub static WORD_EMPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_EMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPE_CHILDREN),
+static WORD_EMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rial"),
         dictgen::InsensitiveStr::Ascii("rially"),
@@ -156052,12 +156052,12 @@ pub static WORD_EMPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_EMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMPA_CHILDREN),
+static WORD_EMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hsize"),
         dictgen::InsensitiveStr::Ascii("hsized"),
@@ -156085,12 +156085,12 @@ pub static WORD_EMPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_EMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMO_CHILDREN),
+static WORD_EMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bdiment"),
         dictgen::InsensitiveStr::Ascii("difying"),
@@ -156116,23 +156116,23 @@ pub static WORD_EMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMN_CHILDREN),
+static WORD_EMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ity")],
     values: &[&["enmity"]],
     range: 3..=3,
 };
 
-static WORD_EMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMM_CHILDREN),
+static WORD_EMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bedding"),
         dictgen::InsensitiveStr::Ascii("ediately"),
@@ -156176,23 +156176,23 @@ pub static WORD_EMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_EML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EML_CHILDREN),
+static WORD_EML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EML_CHILDREN),
     value: None,
 };
 
-pub static WORD_EML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["emulation"]],
     range: 5..=5,
 };
 
-static WORD_EMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMI_CHILDREN),
+static WORD_EMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ited"),
@@ -156228,12 +156228,12 @@ pub static WORD_EMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_EME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EME_CHILDREN),
+static WORD_EME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EME_CHILDREN),
     value: None,
 };
 
-pub static WORD_EME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dded"),
         dictgen::InsensitiveStr::Ascii("grency"),
@@ -156267,12 +156267,12 @@ pub static WORD_EME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_EMC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMC_CHILDREN),
+static WORD_EMC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("ompass"),
@@ -156288,12 +156288,12 @@ pub static WORD_EMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_EMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EMB_CHILDREN),
+static WORD_EMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EMB_CHILDREN),
     value: None,
 };
 
-static WORD_EMB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EMB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_EMBA_NODE),
     Some(&WORD_EMBB_NODE),
     None,
@@ -156322,12 +156322,12 @@ static WORD_EMB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EMBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBR_CHILDREN),
+static WORD_EMBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ago"),
         dictgen::InsensitiveStr::Ascii("io"),
@@ -156338,12 +156338,12 @@ pub static WORD_EMBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_EMBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBO_CHILDREN),
+static WORD_EMBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dyment"),
         dictgen::InsensitiveStr::Ascii("ld"),
@@ -156352,23 +156352,23 @@ pub static WORD_EMBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_EMBL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBL_CHILDREN),
+static WORD_EMBL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("amatic")],
     values: &[&["emblematic"]],
     range: 6..=6,
 };
 
-static WORD_EMBE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBE_CHILDREN),
+static WORD_EMBE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bbed"),
         dictgen::InsensitiveStr::Ascii("dd"),
@@ -156406,12 +156406,12 @@ pub static WORD_EMBE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EMBD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBD_CHILDREN),
+static WORD_EMBD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBD_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("edded"),
@@ -156420,12 +156420,12 @@ pub static WORD_EMBD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_EMBB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBB_CHILDREN),
+static WORD_EMBB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edded"),
         dictgen::InsensitiveStr::Ascii("edding"),
@@ -156441,12 +156441,12 @@ pub static WORD_EMBB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_EMBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMBA_CHILDREN),
+static WORD_EMBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lance"),
         dictgen::InsensitiveStr::Ascii("raasing"),
@@ -156536,12 +156536,12 @@ pub static WORD_EMBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_EMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EMA_CHILDREN),
+static WORD_EMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_EMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baroged"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -156581,12 +156581,12 @@ pub static WORD_EMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_EL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EL_CHILDREN),
+static WORD_EL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EL_CHILDREN),
     value: None,
 };
 
-static WORD_EL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ELA_NODE),
     None,
     Some(&WORD_ELC_NODE),
@@ -156615,12 +156615,12 @@ static WORD_EL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ELS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELS_CHILDREN),
+static WORD_ELS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ef"),
         dictgen::InsensitiveStr::Ascii("ehwere"),
@@ -156648,23 +156648,23 @@ pub static WORD_ELS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ELP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELP_CHILDREN),
+static WORD_ELP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hant")],
     values: &[&["elephant"]],
     range: 4..=4,
 };
 
-static WORD_ELO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELO_CHILDREN),
+static WORD_ELO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctrolytes"),
         dictgen::InsensitiveStr::Ascii("quantly"),
@@ -156682,12 +156682,12 @@ pub static WORD_ELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=9,
 };
 
-static WORD_ELM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELM_CHILDREN),
+static WORD_ELM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enet"),
         dictgen::InsensitiveStr::Ascii("enets"),
@@ -156711,12 +156711,12 @@ pub static WORD_ELM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_ELL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELL_CHILDREN),
+static WORD_ELL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apsed"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -156780,12 +156780,12 @@ pub static WORD_ELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ELI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELI_CHILDREN),
+static WORD_ELI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cided"),
         dictgen::InsensitiveStr::Ascii("gable"),
@@ -156873,23 +156873,23 @@ pub static WORD_ELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ELG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELG_CHILDREN),
+static WORD_ELG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ible")],
     values: &[&["eligible"]],
     range: 4..=4,
 };
 
-static WORD_ELE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ELE_CHILDREN),
+static WORD_ELE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ELE_CHILDREN),
     value: None,
 };
 
-static WORD_ELE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ELE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ELEA_NODE),
     None,
     Some(&WORD_ELEC_NODE),
@@ -156918,23 +156918,23 @@ static WORD_ELE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ELEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEV_CHILDREN),
+static WORD_ELEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atin")],
     values: &[&["elevation"]],
     range: 4..=4,
 };
 
-static WORD_ELET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELET_CHILDREN),
+static WORD_ELET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELET_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ricity"),
         dictgen::InsensitiveStr::Ascii("romagnitic"),
@@ -156950,23 +156950,23 @@ pub static WORD_ELET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_ELES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELES_CHILDREN),
+static WORD_ELES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELES_CHILDREN),
     value: Some(&["eels", "else"]),
 };
 
-pub static WORD_ELES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["else"]],
     range: 1..=1,
 };
 
-static WORD_ELEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEP_CHILDREN),
+static WORD_ELEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahnts"),
         dictgen::InsensitiveStr::Ascii("hans"),
@@ -156986,23 +156986,23 @@ pub static WORD_ELEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ELEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEN_CHILDREN),
+static WORD_ELEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ment")],
     values: &[&["element"]],
     range: 4..=4,
 };
 
-static WORD_ELEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEM_CHILDREN),
+static WORD_ELEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("antary"),
@@ -157088,12 +157088,12 @@ pub static WORD_ELEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ELEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEL_CHILDREN),
+static WORD_ELEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ements"),
@@ -157113,23 +157113,23 @@ pub static WORD_ELEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ELEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEK_CHILDREN),
+static WORD_ELEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("trolytes")],
     values: &[&["electrolytes"]],
     range: 8..=8,
 };
 
-static WORD_ELEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEG_CHILDREN),
+static WORD_ELEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ently"),
         dictgen::InsensitiveStr::Ascii("ible"),
@@ -157138,12 +157138,12 @@ pub static WORD_ELEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_ELEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEE_CHILDREN),
+static WORD_ELEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mnt"),
         dictgen::InsensitiveStr::Ascii("mnts"),
@@ -157153,12 +157153,12 @@ pub static WORD_ELEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ELEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ELEC_CHILDREN),
+static WORD_ELEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ELEC_CHILDREN),
     value: None,
 };
 
-static WORD_ELEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ELEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -157187,12 +157187,12 @@ static WORD_ELEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ELECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ELECT_CHILDREN),
+static WORD_ELECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ELECT_CHILDREN),
     value: None,
 };
 
-static WORD_ELECT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ELECT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -157221,12 +157221,12 @@ static WORD_ELECT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ELECTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECTR_CHILDREN),
+static WORD_ELECTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ial"),
         dictgen::InsensitiveStr::Ascii("icain"),
@@ -157336,12 +157336,12 @@ pub static WORD_ELECTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_ELECTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECTO_CHILDREN),
+static WORD_ELECTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nic"),
@@ -157375,12 +157375,12 @@ pub static WORD_ELECTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_ELECTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECTI_CHILDREN),
+static WORD_ELECTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cal"),
@@ -157400,23 +157400,23 @@ pub static WORD_ELECTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_ELECTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECTH_CHILDREN),
+static WORD_ELECTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("or")],
     values: &[&["electro"]],
     range: 2..=2,
 };
 
-static WORD_ELECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELECR_CHILDREN),
+static WORD_ELECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icity"),
         dictgen::InsensitiveStr::Ascii("to"),
@@ -157432,12 +157432,12 @@ pub static WORD_ELECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_ELEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELEA_CHILDREN),
+static WORD_ELEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("sed"),
@@ -157448,23 +157448,23 @@ pub static WORD_ELEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_ELD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELD_CHILDREN),
+static WORD_ELD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("istribution")],
     values: &[&["redistribution"]],
     range: 11..=11,
 };
 
-static WORD_ELC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELC_CHILDREN),
+static WORD_ELC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ipse"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -157474,12 +157474,12 @@ pub static WORD_ELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_ELA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ELA_CHILDREN),
+static WORD_ELA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ELA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ELA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ELA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gance"),
         dictgen::InsensitiveStr::Ascii("gant"),
@@ -157511,12 +157511,12 @@ pub static WORD_ELA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_EJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EJ_CHILDREN),
+static WORD_EJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_EJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acluation"),
         dictgen::InsensitiveStr::Ascii("acualte"),
@@ -157542,12 +157542,12 @@ pub static WORD_EJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=10,
 };
 
-static WORD_EI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EI_CHILDREN),
+static WORD_EI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egn"),
         dictgen::InsensitiveStr::Ascii("fnach"),
@@ -157597,12 +157597,12 @@ pub static WORD_EI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_EH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EH_CHILDREN),
+static WORD_EH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("anced"),
@@ -157646,12 +157646,12 @@ pub static WORD_EH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_EG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EG_CHILDREN),
+static WORD_EG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aletarian"),
@@ -157727,12 +157727,12 @@ pub static WORD_EG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_EF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EF_CHILDREN),
+static WORD_EF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EF_CHILDREN),
     value: None,
 };
 
-static WORD_EF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -157761,12 +157761,12 @@ static WORD_EF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFO_CHILDREN),
+static WORD_EFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rceable"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -157775,12 +157775,12 @@ pub static WORD_EFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_EFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFI_CHILDREN),
+static WORD_EFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cient"),
         dictgen::InsensitiveStr::Ascii("nitions"),
@@ -157789,12 +157789,12 @@ pub static WORD_EFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_EFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EFF_CHILDREN),
+static WORD_EFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EFF_CHILDREN),
     value: None,
 };
 
-static WORD_EFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EFF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_EFFC_NODE),
@@ -157823,23 +157823,23 @@ static WORD_EFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_EFFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFU_CHILDREN),
+static WORD_EFFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lence")],
     values: &[&["effluence"]],
     range: 5..=5,
 };
 
-static WORD_EFFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFO_CHILDREN),
+static WORD_EFFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rdlessly"),
@@ -157861,12 +157861,12 @@ pub static WORD_EFFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_EFFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFI_CHILDREN),
+static WORD_EFFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccient"),
         dictgen::InsensitiveStr::Ascii("ceincy"),
@@ -157922,12 +157922,12 @@ pub static WORD_EFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_EFFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFE_CHILDREN),
+static WORD_EFFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceively"),
         dictgen::InsensitiveStr::Ascii("ciency"),
@@ -157993,12 +157993,12 @@ pub static WORD_EFFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_EFFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFFC_CHILDREN),
+static WORD_EFFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iency"),
         dictgen::InsensitiveStr::Ascii("ient"),
@@ -158016,12 +158016,12 @@ pub static WORD_EFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_EFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EFE_CHILDREN),
+static WORD_EFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -158041,12 +158041,12 @@ pub static WORD_EFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_EE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EE_CHILDREN),
+static WORD_EE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EE_CHILDREN),
     value: None,
 };
 
-pub static WORD_EE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arly"),
         dictgen::InsensitiveStr::Ascii("cutable"),
@@ -158088,12 +158088,12 @@ pub static WORD_EE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ED_CHILDREN),
+static WORD_ED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ED_CHILDREN),
     value: None,
 };
 
-pub static WORD_ED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biles"),
         dictgen::InsensitiveStr::Ascii("cdic"),
@@ -158187,12 +158187,12 @@ pub static WORD_ED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_EC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EC_CHILDREN),
+static WORD_EC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ape"),
         dictgen::InsensitiveStr::Ascii("ause"),
@@ -158326,12 +158326,12 @@ pub static WORD_EC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_EB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EB_CHILDREN),
+static WORD_EB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -158351,12 +158351,12 @@ pub static WORD_EB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_EA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_EA_CHILDREN),
+static WORD_EA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_EA_CHILDREN),
     value: None,
 };
 
-static WORD_EA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_EA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_EAB_NODE),
     Some(&WORD_EAC_NODE),
@@ -158385,12 +158385,12 @@ static WORD_EA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_EAZ_NODE),
 ];
 
-static WORD_EAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAZ_CHILDREN),
+static WORD_EAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ier"),
         dictgen::InsensitiveStr::Ascii("iest"),
@@ -158400,34 +158400,34 @@ pub static WORD_EAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_EAX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAX_CHILDREN),
+static WORD_EAX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAX_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ct")],
     values: &[&["exact"]],
     range: 2..=2,
 };
 
-static WORD_EAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAU_CHILDREN),
+static WORD_EAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ality")],
     values: &[&["equality"]],
     range: 5..=5,
 };
 
-static WORD_EAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAT_CHILDREN),
+static WORD_EAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("her"),
         dictgen::InsensitiveStr::Ascii("swood"),
@@ -158443,12 +158443,12 @@ pub static WORD_EAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_EAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAS_CHILDREN),
+static WORD_EAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ely"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -158492,12 +158492,12 @@ pub static WORD_EAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_EAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAR_CHILDREN),
+static WORD_EAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("htbound"),
@@ -158565,12 +158565,12 @@ pub static WORD_EAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_EAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAN_CHILDREN),
+static WORD_EAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -158580,12 +158580,12 @@ pub static WORD_EAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_EAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAM_CHILDREN),
+static WORD_EAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cs"),
         dictgen::InsensitiveStr::Ascii("il"),
@@ -158596,12 +158596,12 @@ pub static WORD_EAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_EAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAL_CHILDREN),
+static WORD_EAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ier"),
         dictgen::InsensitiveStr::Ascii("iest"),
@@ -158612,12 +158612,12 @@ pub static WORD_EAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_EAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAI_CHILDREN),
+static WORD_EAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lier"),
         dictgen::InsensitiveStr::Ascii("ser"),
@@ -158627,34 +158627,34 @@ pub static WORD_EAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_EAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAH_CHILDREN),
+static WORD_EAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("c")],
     values: &[&["each"]],
     range: 1..=1,
 };
 
-static WORD_EAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAG_CHILDREN),
+static WORD_EAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rely")],
     values: &[&["eagerly"]],
     range: 4..=4,
 };
 
-static WORD_EAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAC_CHILDREN),
+static WORD_EAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -158676,23 +158676,23 @@ pub static WORD_EAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_EAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_EAB_CHILDREN),
+static WORD_EAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_EAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_EAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_EAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("led")],
     values: &[&["enabled"]],
     range: 3..=3,
 };
 
-static WORD_D_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_D_CHILDREN),
+static WORD_D_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_D_CHILDREN),
     value: None,
 };
 
-static WORD_D_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_D_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DA_NODE),
     Some(&WORD_DB_NODE),
     Some(&WORD_DC_NODE),
@@ -158721,12 +158721,12 @@ static WORD_D_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DY_CHILDREN),
+static WORD_DY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amically"),
         dictgen::InsensitiveStr::Ascii("anamically"),
@@ -158860,34 +158860,34 @@ pub static WORD_DY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_DW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DW_CHILDREN),
+static WORD_DW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arvens")],
     values: &[&["dwarves"]],
     range: 6..=6,
 };
 
-static WORD_DV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DV_CHILDREN),
+static WORD_DV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ided")],
     values: &[&["divided"]],
     range: 4..=4,
 };
 
-static WORD_DU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DU_CHILDREN),
+static WORD_DU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DU_CHILDREN),
     value: None,
 };
 
-static WORD_DU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DUA_NODE),
     Some(&WORD_DUB_NODE),
     Some(&WORD_DUC_NODE),
@@ -158916,23 +158916,23 @@ static WORD_DU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUT_CHILDREN),
+static WORD_DUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["during"]],
     range: 3..=3,
 };
 
-static WORD_DUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUS_CHILDREN),
+static WORD_DUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("btep"),
         dictgen::InsensitiveStr::Ascii("functional"),
@@ -158948,12 +158948,12 @@ pub static WORD_DUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_DUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUR_CHILDREN),
+static WORD_DUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abiliy"),
         dictgen::InsensitiveStr::Ascii("abillity"),
@@ -158995,12 +158995,12 @@ pub static WORD_DUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_DUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUP_CHILDREN),
+static WORD_DUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icate"),
         dictgen::InsensitiveStr::Ascii("ilcates"),
@@ -159124,23 +159124,23 @@ pub static WORD_DUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_DUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUO_CHILDREN),
+static WORD_DUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("blequote")],
     values: &[&["doublequote"]],
     range: 8..=8,
 };
 
-static WORD_DUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUN_CHILDREN),
+static WORD_DUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egon"),
         dictgen::InsensitiveStr::Ascii("egons"),
@@ -159162,12 +159162,12 @@ pub static WORD_DUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_DUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUM_CHILDREN),
+static WORD_DUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUM_CHILDREN),
     value: Some(&["dumb"]),
 };
 
-pub static WORD_DUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bbellls"),
         dictgen::InsensitiveStr::Ascii("bbels"),
@@ -159201,12 +159201,12 @@ pub static WORD_DUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_DUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUL_CHILDREN),
+static WORD_DUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aity"),
         dictgen::InsensitiveStr::Ascii("eing"),
@@ -159216,12 +159216,12 @@ pub static WORD_DUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_DUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUI_CHILDREN),
+static WORD_DUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("rng"),
@@ -159230,12 +159230,12 @@ pub static WORD_DUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_DUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUE_CHILDREN),
+static WORD_DUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -159249,23 +159249,23 @@ pub static WORD_DUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_DUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUD_CHILDREN),
+static WORD_DUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("o")],
     values: &[&["sudo"]],
     range: 1..=1,
 };
 
-static WORD_DUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUC_CHILDREN),
+static WORD_DUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("ument"),
@@ -159274,12 +159274,12 @@ pub static WORD_DUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_DUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUB_CHILDREN),
+static WORD_DUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ios"),
         dictgen::InsensitiveStr::Ascii("le"),
@@ -159317,12 +159317,12 @@ pub static WORD_DUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DUA_CHILDREN),
+static WORD_DUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghter"),
         dictgen::InsensitiveStr::Ascii("ghters"),
@@ -159333,12 +159333,12 @@ pub static WORD_DUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_DT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DT_CHILDREN),
+static WORD_DT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erminated"),
         dictgen::InsensitiveStr::Ascii("he"),
@@ -159348,12 +159348,12 @@ pub static WORD_DT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DS_CHILDREN),
+static WORD_DS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crete"),
         dictgen::InsensitiveStr::Ascii("cretion"),
@@ -159387,12 +159387,12 @@ pub static WORD_DS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_DR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DR_CHILDREN),
+static WORD_DR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DR_CHILDREN),
     value: None,
 };
 
-static WORD_DR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DRA_NODE),
     None,
     None,
@@ -159421,12 +159421,12 @@ static WORD_DR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRW_CHILDREN),
+static WORD_DRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("awing"),
@@ -159436,23 +159436,23 @@ pub static WORD_DRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_DRV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRV_CHILDREN),
+static WORD_DRV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ier")],
     values: &[&["driver"]],
     range: 3..=3,
 };
 
-static WORD_DRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRU_CHILDREN),
+static WORD_DRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ming"),
@@ -159463,12 +159463,12 @@ pub static WORD_DRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_DRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRO_CHILDREN),
+static WORD_DRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("pabel"),
@@ -159502,23 +159502,23 @@ pub static WORD_DRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_DRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRN_CHILDREN),
+static WORD_DRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ik")],
     values: &[&["drink"]],
     range: 2..=2,
 };
 
-static WORD_DRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRI_CHILDREN),
+static WORD_DRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agram"),
         dictgen::InsensitiveStr::Ascii("agrammed"),
@@ -159564,23 +159564,23 @@ pub static WORD_DRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRF_CHILDREN),
+static WORD_DRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iting")],
     values: &[&["drifting"]],
     range: 5..=5,
 };
 
-static WORD_DRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRE_CHILDREN),
+static WORD_DRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asm"),
         dictgen::InsensitiveStr::Ascii("awn"),
@@ -159606,12 +159606,12 @@ pub static WORD_DRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_DRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DRA_CHILDREN),
+static WORD_DRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clua"),
         dictgen::InsensitiveStr::Ascii("conain"),
@@ -159685,12 +159685,12 @@ pub static WORD_DRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_DP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DP_CHILDREN),
+static WORD_DP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eends"),
         dictgen::InsensitiveStr::Ascii("endent"),
@@ -159701,12 +159701,12 @@ pub static WORD_DP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_DO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DO_CHILDREN),
+static WORD_DO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DO_CHILDREN),
     value: None,
 };
 
-static WORD_DO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DOA_NODE),
     Some(&WORD_DOB_NODE),
     Some(&WORD_DOC_NODE),
@@ -159735,34 +159735,34 @@ static WORD_DO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOY_CHILDREN),
+static WORD_DOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gen")],
     values: &[&["doxygen"]],
     range: 3..=3,
 };
 
-static WORD_DOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOX_CHILDREN),
+static WORD_DOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gen")],
     values: &[&["doxygen"]],
     range: 3..=3,
 };
 
-static WORD_DOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DOW_CHILDREN),
+static WORD_DOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DOW_CHILDREN),
     value: None,
 };
 
-static WORD_DOW_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DOW_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -159791,34 +159791,34 @@ static WORD_DOW_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOWT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWT_CHILDREN),
+static WORD_DOWT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWT_CHILDREN),
     value: Some(&["doubt"]),
 };
 
-pub static WORD_DOWT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DOWS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWS_CHILDREN),
+static WORD_DOWS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWS_CHILDREN),
     value: Some(&["does"]),
 };
 
-pub static WORD_DOWS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DOWR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWR_CHILDREN),
+static WORD_DOWR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ds"),
@@ -159827,12 +159827,12 @@ pub static WORD_DOWR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_DOWN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DOWN_CHILDREN),
+static WORD_DOWN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DOWN_CHILDREN),
     value: None,
 };
 
-static WORD_DOWN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DOWN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DOWNA_NODE),
     None,
     Some(&WORD_DOWNC_NODE),
@@ -159861,12 +159861,12 @@ static WORD_DOWN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOWNW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNW_CHILDREN),
+static WORD_DOWNW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oters"),
         dictgen::InsensitiveStr::Ascii("oting"),
@@ -159875,12 +159875,12 @@ pub static WORD_DOWNW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_DOWNV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNV_CHILDREN),
+static WORD_DOWNV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iting"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -159934,12 +159934,12 @@ pub static WORD_DOWNV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DOWNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNT_CHILDREN),
+static WORD_DOWNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("okers"),
         dictgen::InsensitiveStr::Ascii("oking"),
@@ -159949,12 +159949,12 @@ pub static WORD_DOWNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_DOWNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNS_CHILDREN),
+static WORD_DOWNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iders"),
         dictgen::InsensitiveStr::Ascii("tar"),
@@ -159986,12 +159986,12 @@ pub static WORD_DOWNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DOWNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNR_CHILDREN),
+static WORD_DOWNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -160017,12 +160017,12 @@ pub static WORD_DOWNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DOWNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNO_CHILDREN),
+static WORD_DOWNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -160050,12 +160050,12 @@ pub static WORD_DOWNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DOWNL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNL_CHILDREN),
+static WORD_DOWNL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -160121,12 +160121,12 @@ pub static WORD_DOWNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DOWNG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNG_CHILDREN),
+static WORD_DOWNG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -160186,23 +160186,23 @@ pub static WORD_DOWNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DOWNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNC_CHILDREN),
+static WORD_DOWNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ale")],
     values: &[&["downscale"]],
     range: 3..=3,
 };
 
-static WORD_DOWNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWNA_CHILDREN),
+static WORD_DOWNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("grade"),
         dictgen::InsensitiveStr::Ascii("graded"),
@@ -160218,12 +160218,12 @@ pub static WORD_DOWNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DOWL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWL_CHILDREN),
+static WORD_DOWL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ink"),
         dictgen::InsensitiveStr::Ascii("inks"),
@@ -160247,23 +160247,23 @@ pub static WORD_DOWL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DOWG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOWG_CHILDREN),
+static WORD_DOWG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOWG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOWG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOWG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rade")],
     values: &[&["downgrade"]],
     range: 4..=4,
 };
 
-static WORD_DOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOU_CHILDREN),
+static WORD_DOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -160353,12 +160353,12 @@ pub static WORD_DOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_DOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOT_CHILDREN),
+static WORD_DOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("rmund"),
@@ -160367,12 +160367,12 @@ pub static WORD_DOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_DOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOS_CHILDREN),
+static WORD_DOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("closed"),
         dictgen::InsensitiveStr::Ascii("closes"),
@@ -160410,12 +160410,12 @@ pub static WORD_DOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOR_CHILDREN),
+static WORD_DOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -160443,12 +160443,12 @@ pub static WORD_DOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_DOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOP_CHILDREN),
+static WORD_DOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lhin"),
         dictgen::InsensitiveStr::Ascii("lhins"),
@@ -160459,12 +160459,12 @@ pub static WORD_DOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_DOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOO_CHILDREN),
+static WORD_DOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cument"),
         dictgen::InsensitiveStr::Ascii("cumentaries"),
@@ -160496,12 +160496,12 @@ pub static WORD_DOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_DON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DON_CHILDREN),
+static WORD_DON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DON_CHILDREN),
     value: None,
 };
 
-pub static WORD_DON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ains"),
@@ -160551,12 +160551,12 @@ pub static WORD_DON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_DOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOM_CHILDREN),
+static WORD_DOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ainate"),
         dictgen::InsensitiveStr::Ascii("ait"),
@@ -160648,12 +160648,12 @@ pub static WORD_DOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_DOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOL_CHILDREN),
+static WORD_DOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hpin"),
         dictgen::InsensitiveStr::Ascii("hpins"),
@@ -160679,12 +160679,12 @@ pub static WORD_DOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_DOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOK_CHILDREN),
+static WORD_DOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -160710,12 +160710,12 @@ pub static WORD_DOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_DOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOI_CHILDREN),
+static WORD_DOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -160733,12 +160733,12 @@ pub static WORD_DOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_DOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOG_CHILDREN),
+static WORD_DOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amtic"),
         dictgen::InsensitiveStr::Ascii("dammit"),
@@ -160758,12 +160758,12 @@ pub static WORD_DOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_DOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOE_CHILDREN),
+static WORD_DOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -160783,12 +160783,12 @@ pub static WORD_DOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_DOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DOC_CHILDREN),
+static WORD_DOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DOC_CHILDREN),
     value: None,
 };
 
-static WORD_DOC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DOC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DOCC_NODE),
@@ -160817,12 +160817,12 @@ static WORD_DOC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DOCU_CHILDREN),
+static WORD_DOCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DOCU_CHILDREN),
     value: None,
 };
 
-static WORD_DOCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DOCU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DOCUC_NODE),
@@ -160851,23 +160851,23 @@ static WORD_DOCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DOCUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUN_CHILDREN),
+static WORD_DOCUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ment")],
     values: &[&["document"]],
     range: 4..=4,
 };
 
-static WORD_DOCUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUM_CHILDREN),
+static WORD_DOCUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("antaries"),
@@ -160991,12 +160991,12 @@ pub static WORD_DOCUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_DOCUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUH_CHILDREN),
+static WORD_DOCUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebag"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -161006,12 +161006,12 @@ pub static WORD_DOCUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_DOCUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUE_CHILDREN),
+static WORD_DOCUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("ments"),
@@ -161041,23 +161041,23 @@ pub static WORD_DOCUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DOCUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCUC_CHILDREN),
+static WORD_DOCUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ument")],
     values: &[&["document"]],
     range: 5..=5,
 };
 
-static WORD_DOCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCT_CHILDREN),
+static WORD_DOCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ines"),
         dictgen::InsensitiveStr::Ascii("irne"),
@@ -161068,12 +161068,12 @@ pub static WORD_DOCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_DOCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCS_CHILDREN),
+static WORD_DOCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tatistik"),
         dictgen::InsensitiveStr::Ascii("tinrg"),
@@ -161083,12 +161083,12 @@ pub static WORD_DOCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DOCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCR_CHILDREN),
+static WORD_DOCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ines"),
         dictgen::InsensitiveStr::Ascii("tine"),
@@ -161098,12 +161098,12 @@ pub static WORD_DOCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_DOCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCO_CHILDREN),
+static WORD_DOCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mentation"),
@@ -161121,12 +161121,12 @@ pub static WORD_DOCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DOCM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCM_CHILDREN),
+static WORD_DOCM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enetation"),
         dictgen::InsensitiveStr::Ascii("uent"),
@@ -161148,34 +161148,34 @@ pub static WORD_DOCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DOCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCK_CHILDREN),
+static WORD_DOCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("son")],
     values: &[&["dachshund"]],
     range: 3..=3,
 };
 
-static WORD_DOCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCE_CHILDREN),
+static WORD_DOCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("kr")],
     values: &[&["docker"]],
     range: 2..=2,
 };
 
-static WORD_DOCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOCC_CHILDREN),
+static WORD_DOCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ument"),
         dictgen::InsensitiveStr::Ascii("umented"),
@@ -161185,12 +161185,12 @@ pub static WORD_DOCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOB_CHILDREN),
+static WORD_DOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -161210,12 +161210,12 @@ pub static WORD_DOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_DOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DOA_CHILDREN),
+static WORD_DOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gonal"),
         dictgen::InsensitiveStr::Ascii("gonals"),
@@ -161237,12 +161237,12 @@ pub static WORD_DOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_DN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DN_CHILDREN),
+static WORD_DN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amically"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -161252,12 +161252,12 @@ pub static WORD_DN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DL_CHILDREN),
+static WORD_DL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eivery"),
         dictgen::InsensitiveStr::Ascii("oating"),
@@ -161266,23 +161266,23 @@ pub static WORD_DL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=6,
 };
 
-static WORD_DJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DJ_CHILDREN),
+static WORD_DJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ikstra")],
     values: &[&["dijkstra"]],
     range: 6..=6,
 };
 
-static WORD_DI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DI_CHILDREN),
+static WORD_DI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DI_CHILDREN),
     value: None,
 };
 
-static WORD_DI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DIA_NODE),
     None,
     Some(&WORD_DIC_NODE),
@@ -161311,12 +161311,12 @@ static WORD_DI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIV_CHILDREN),
+static WORD_DIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -161406,12 +161406,12 @@ pub static WORD_DIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIT_CHILDREN),
+static WORD_DIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actorship"),
         dictgen::InsensitiveStr::Ascii("ance"),
@@ -161443,12 +161443,12 @@ pub static WORD_DIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_DIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIS_CHILDREN),
+static WORD_DIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIS_CHILDREN),
     value: None,
 };
 
-static WORD_DIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISA_NODE),
     Some(&WORD_DISB_NODE),
     Some(&WORD_DISC_NODE),
@@ -161477,12 +161477,12 @@ static WORD_DIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISU_CHILDREN),
+static WORD_DISU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("css"),
@@ -161522,12 +161522,12 @@ pub static WORD_DISU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DIST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIST_CHILDREN),
+static WORD_DIST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIST_CHILDREN),
     value: None,
 };
 
-static WORD_DIST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISTA_NODE),
     None,
     None,
@@ -161556,12 +161556,12 @@ static WORD_DIST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTU_CHILDREN),
+static WORD_DISTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bring"),
         dictgen::InsensitiveStr::Ascii("ingish"),
@@ -161593,12 +161593,12 @@ pub static WORD_DISTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DISTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTT_CHILDREN),
+static WORD_DISTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ributed"),
         dictgen::InsensitiveStr::Ascii("ribution"),
@@ -161607,12 +161607,12 @@ pub static WORD_DISTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_DISTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISTR_CHILDREN),
+static WORD_DISTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISTR_CHILDREN),
     value: None,
 };
 
-static WORD_DISTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISTRA_NODE),
     Some(&WORD_DISTRB_NODE),
     Some(&WORD_DISTRC_NODE),
@@ -161641,12 +161641,12 @@ static WORD_DISTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRU_CHILDREN),
+static WORD_DISTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("bance"),
@@ -161710,12 +161710,12 @@ pub static WORD_DISTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_DISTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRO_CHILDREN),
+static WORD_DISTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bute"),
         dictgen::InsensitiveStr::Ascii("buted"),
@@ -161741,12 +161741,12 @@ pub static WORD_DISTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_DISTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRI_CHILDREN),
+static WORD_DISTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bitor"),
         dictgen::InsensitiveStr::Ascii("bitors"),
@@ -161840,23 +161840,23 @@ pub static WORD_DISTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_DISTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRE_CHILDREN),
+static WORD_DISTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("buted")],
     values: &[&["distributed"]],
     range: 5..=5,
 };
 
-static WORD_DISTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRC_CHILDREN),
+static WORD_DISTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("it"),
         dictgen::InsensitiveStr::Ascii("its"),
@@ -161867,12 +161867,12 @@ pub static WORD_DISTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_DISTRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRB_CHILDREN),
+static WORD_DISTRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ute"),
         dictgen::InsensitiveStr::Ascii("uted"),
@@ -161892,12 +161892,12 @@ pub static WORD_DISTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_DISTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTRA_CHILDREN),
+static WORD_DISTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bution"),
         dictgen::InsensitiveStr::Ascii("ccion"),
@@ -161923,12 +161923,12 @@ pub static WORD_DISTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_DISTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTO_CHILDREN),
+static WORD_DISTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rition"),
         dictgen::InsensitiveStr::Ascii("riton"),
@@ -161954,12 +161954,12 @@ pub static WORD_DISTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DISTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTN_CHILDREN),
+static WORD_DISTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aces"),
@@ -161989,12 +161989,12 @@ pub static WORD_DISTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DISTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISTI_CHILDREN),
+static WORD_DISTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISTI_CHILDREN),
     value: None,
 };
 
-static WORD_DISTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DISTIB_NODE),
     Some(&WORD_DISTIC_NODE),
@@ -162023,23 +162023,23 @@ static WORD_DISTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIU_CHILDREN),
+static WORD_DISTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ngished")],
     values: &[&["distinguished"]],
     range: 7..=7,
 };
 
-static WORD_DISTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIR_CHILDREN),
+static WORD_DISTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bance"),
         dictgen::InsensitiveStr::Ascii("bute"),
@@ -162065,12 +162065,12 @@ pub static WORD_DISTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_DISTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIN_CHILDREN),
+static WORD_DISTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -162160,12 +162160,12 @@ pub static WORD_DISTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_DISTIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIG_CHILDREN),
+static WORD_DISTIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uish"),
         dictgen::InsensitiveStr::Ascii("uished"),
@@ -162174,12 +162174,12 @@ pub static WORD_DISTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_DISTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIC_CHILDREN),
+static WORD_DISTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("ntion"),
@@ -162197,12 +162197,12 @@ pub static WORD_DISTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_DISTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTIB_CHILDREN),
+static WORD_DISTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ute"),
         dictgen::InsensitiveStr::Ascii("uted"),
@@ -162224,12 +162224,12 @@ pub static WORD_DISTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_DISTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTE_CHILDREN),
+static WORD_DISTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ngish"),
         dictgen::InsensitiveStr::Ascii("rbance"),
@@ -162238,12 +162238,12 @@ pub static WORD_DISTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_DISTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISTA_CHILDREN),
+static WORD_DISTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -162285,12 +162285,12 @@ pub static WORD_DISTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DISS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISS_CHILDREN),
+static WORD_DISS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISS_CHILDREN),
     value: None,
 };
 
-static WORD_DISS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISSA_NODE),
     Some(&WORD_DISSB_NODE),
     Some(&WORD_DISSC_NODE),
@@ -162319,12 +162319,12 @@ static WORD_DISS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSS_CHILDREN),
+static WORD_DISSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emble"),
         dictgen::InsensitiveStr::Ascii("embled"),
@@ -162356,12 +162356,12 @@ pub static WORD_DISSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_DISSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSR_CHILDREN),
+static WORD_DISSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("upt"),
         dictgen::InsensitiveStr::Ascii("upted"),
@@ -162372,12 +162372,12 @@ pub static WORD_DISSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DISSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSP_CHILDREN),
+static WORD_DISSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aointed"),
         dictgen::InsensitiveStr::Ascii("iate"),
@@ -162393,12 +162393,12 @@ pub static WORD_DISSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DISSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSO_CHILDREN),
+static WORD_DISSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bediance"),
         dictgen::InsensitiveStr::Ascii("bediant"),
@@ -162426,12 +162426,12 @@ pub static WORD_DISSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DISSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSM_CHILDREN),
+static WORD_DISSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antle"),
         dictgen::InsensitiveStr::Ascii("antled"),
@@ -162467,12 +162467,12 @@ pub static WORD_DISSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DISSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSI_CHILDREN),
+static WORD_DISSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mialr"),
         dictgen::InsensitiveStr::Ascii("mialrity"),
@@ -162528,23 +162528,23 @@ pub static WORD_DISSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DISSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSH_CHILDREN),
+static WORD_DISSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("earteningly")],
     values: &[&["dishearteningly"]],
     range: 11..=11,
 };
 
-static WORD_DISSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSE_CHILDREN),
+static WORD_DISSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pointed"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -162554,12 +162554,12 @@ pub static WORD_DISSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_DISSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSC_CHILDREN),
+static WORD_DISSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onect"),
         dictgen::InsensitiveStr::Ascii("onnect"),
@@ -162623,12 +162623,12 @@ pub static WORD_DISSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISSB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSB_CHILDREN),
+static WORD_DISSB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -162639,12 +162639,12 @@ pub static WORD_DISSB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_DISSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISSA_CHILDREN),
+static WORD_DISSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISSA_CHILDREN),
     value: None,
 };
 
-static WORD_DISSA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISSA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DISSAB_NODE),
     None,
@@ -162673,12 +162673,12 @@ static WORD_DISSA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISSAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAT_CHILDREN),
+static WORD_DISSAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isfed"),
         dictgen::InsensitiveStr::Ascii("isifed"),
@@ -162688,12 +162688,12 @@ pub static WORD_DISSAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_DISSAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAS_CHILDREN),
+static WORD_DISSAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emble"),
         dictgen::InsensitiveStr::Ascii("embled"),
@@ -162751,23 +162751,23 @@ pub static WORD_DISSAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_DISSAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAR_CHILDREN),
+static WORD_DISSAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ray")],
     values: &[&["disarray"]],
     range: 3..=3,
 };
 
-static WORD_DISSAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAP_CHILDREN),
+static WORD_DISSAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ates"),
@@ -162861,12 +162861,12 @@ pub static WORD_DISSAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_DISSAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAM_CHILDREN),
+static WORD_DISSAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biguate"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -162890,12 +162890,12 @@ pub static WORD_DISSAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_DISSAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAL_CHILDREN),
+static WORD_DISSAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("low"),
         dictgen::InsensitiveStr::Ascii("lowed"),
@@ -162919,12 +162919,12 @@ pub static WORD_DISSAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_DISSAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAG_CHILDREN),
+static WORD_DISSAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("reement"),
         dictgen::InsensitiveStr::Ascii("regation"),
@@ -162933,12 +162933,12 @@ pub static WORD_DISSAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=8,
 };
 
-static WORD_DISSAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAD_CHILDREN),
+static WORD_DISSAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("vantage"),
         dictgen::InsensitiveStr::Ascii("vantages"),
@@ -162947,12 +162947,12 @@ pub static WORD_DISSAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 7..=8,
 };
 
-static WORD_DISSAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISSAB_CHILDREN),
+static WORD_DISSAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISSAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISSAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISSAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -162963,12 +162963,12 @@ pub static WORD_DISSAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_DISR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISR_CHILDREN),
+static WORD_DISR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecpect"),
         dictgen::InsensitiveStr::Ascii("ecpected"),
@@ -163058,12 +163058,12 @@ pub static WORD_DISR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_DISQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISQ_CHILDREN),
+static WORD_DISQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aulified"),
         dictgen::InsensitiveStr::Ascii("ualifed"),
@@ -163079,12 +163079,12 @@ pub static WORD_DISQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_DISP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISP_CHILDREN),
+static WORD_DISP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISP_CHILDREN),
     value: None,
 };
 
-static WORD_DISP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISPA_NODE),
     Some(&WORD_DISPB_NODE),
     None,
@@ -163113,12 +163113,12 @@ static WORD_DISP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPU_CHILDREN),
+static WORD_DISPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("tandem"),
@@ -163134,23 +163134,23 @@ pub static WORD_DISPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DISPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPT_CHILDREN),
+static WORD_DISPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ach")],
     values: &[&["dispatch"]],
     range: 3..=3,
 };
 
-static WORD_DISPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPR_CHILDREN),
+static WORD_DISPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aportionate"),
         dictgen::InsensitiveStr::Ascii("aportionately"),
@@ -163188,12 +163188,12 @@ pub static WORD_DISPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=14,
 };
 
-static WORD_DISPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPP_CHILDREN),
+static WORD_DISPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lay"),
         dictgen::InsensitiveStr::Ascii("rove"),
@@ -163202,12 +163202,12 @@ pub static WORD_DISPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DISPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPO_CHILDREN),
+static WORD_DISPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -163261,12 +163261,12 @@ pub static WORD_DISPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_DISPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPL_CHILDREN),
+static WORD_DISPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("acemnt"),
@@ -163304,12 +163304,12 @@ pub static WORD_DISPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DISPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPI_CHILDREN),
+static WORD_DISPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("rsed"),
@@ -163319,12 +163319,12 @@ pub static WORD_DISPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DISPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPE_CHILDREN),
+static WORD_DISPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("ll"),
@@ -163376,23 +163376,23 @@ pub static WORD_DISPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_DISPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPB_CHILDREN),
+static WORD_DISPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ibute")],
     values: &[&["distribute"]],
     range: 5..=5,
 };
 
-static WORD_DISPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISPA_CHILDREN),
+static WORD_DISPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cement"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -163458,12 +163458,12 @@ pub static WORD_DISPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISO_CHILDREN),
+static WORD_DISO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bediance"),
         dictgen::InsensitiveStr::Ascii("bediant"),
@@ -163503,12 +163503,12 @@ pub static WORD_DISO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DISN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISN_CHILDREN),
+static WORD_DISN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abled"),
         dictgen::InsensitiveStr::Ascii("egage"),
@@ -163517,12 +163517,12 @@ pub static WORD_DISN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_DISM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISM_CHILDREN),
+static WORD_DISM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abiguation"),
         dictgen::InsensitiveStr::Ascii("anlting"),
@@ -163558,12 +163558,12 @@ pub static WORD_DISM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_DISL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISL_CHILDREN),
+static WORD_DISL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aimer"),
         dictgen::InsensitiveStr::Ascii("ay"),
@@ -163595,12 +163595,12 @@ pub static WORD_DISL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DISK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISK_CHILDREN),
+static WORD_DISK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rete"),
         dictgen::InsensitiveStr::Ascii("retion"),
@@ -163620,12 +163620,12 @@ pub static WORD_DISK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_DISI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISI_CHILDREN),
+static WORD_DISI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cples"),
         dictgen::InsensitiveStr::Ascii("cpline"),
@@ -163679,12 +163679,12 @@ pub static WORD_DISI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_DISH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISH_CHILDREN),
+static WORD_DISH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arge"),
         dictgen::InsensitiveStr::Ascii("carged"),
@@ -163706,12 +163706,12 @@ pub static WORD_DISH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DISG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISG_CHILDREN),
+static WORD_DISG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arded"),
         dictgen::InsensitiveStr::Ascii("areement"),
@@ -163793,12 +163793,12 @@ pub static WORD_DISG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISF_CHILDREN),
+static WORD_DISF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("unctional"),
         dictgen::InsensitiveStr::Ascii("unctionality"),
@@ -163807,12 +163807,12 @@ pub static WORD_DISF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 9..=12,
 };
 
-static WORD_DISE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISE_CHILDREN),
+static WORD_DISE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cting"),
         dictgen::InsensitiveStr::Ascii("ction"),
@@ -163844,23 +163844,23 @@ pub static WORD_DISE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DISD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISD_CHILDREN),
+static WORD_DISD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("vantage")],
     values: &[&["disadvantage"]],
     range: 7..=7,
 };
 
-static WORD_DISC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISC_CHILDREN),
+static WORD_DISC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISC_CHILDREN),
     value: None,
 };
 
-static WORD_DISC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISCA_NODE),
     None,
     Some(&WORD_DISCC_NODE),
@@ -163889,12 +163889,12 @@ static WORD_DISC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCU_CHILDREN),
+static WORD_DISCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alified"),
         dictgen::InsensitiveStr::Ascii("assed"),
@@ -163938,12 +163938,12 @@ pub static WORD_DISCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DISCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCT_CHILDREN),
+static WORD_DISCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inction"),
         dictgen::InsensitiveStr::Ascii("inctive"),
@@ -163963,12 +163963,12 @@ pub static WORD_DISCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_DISCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCR_CHILDREN),
+static WORD_DISCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("aced"),
@@ -164080,23 +164080,23 @@ pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DISCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCP_CHILDREN),
+static WORD_DISCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("line")],
     values: &[&["discipline"]],
     range: 4..=4,
 };
 
-static WORD_DISCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISCO_CHILDREN),
+static WORD_DISCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISCO_CHILDREN),
     value: None,
 };
 
-static WORD_DISCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -164125,12 +164125,12 @@ static WORD_DISCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISCOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOV_CHILDREN),
+static WORD_DISCOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -164166,12 +164166,12 @@ pub static WORD_DISCOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_DISCOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOU_CHILDREN),
+static WORD_DISCOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ntined"),
@@ -164201,12 +164201,12 @@ pub static WORD_DISCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_DISCOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOT_CHILDREN),
+static WORD_DISCOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ek"),
         dictgen::InsensitiveStr::Ascii("eque"),
@@ -164215,23 +164215,23 @@ pub static WORD_DISCOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_DISCOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOS_CHILDREN),
+static WORD_DISCOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ure")],
     values: &[&["discourse"]],
     range: 3..=3,
 };
 
-static WORD_DISCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOR_CHILDREN),
+static WORD_DISCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aged"),
         dictgen::InsensitiveStr::Ascii("uage"),
@@ -164240,12 +164240,12 @@ pub static WORD_DISCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=4,
 };
 
-static WORD_DISCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCON_CHILDREN),
+static WORD_DISCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCON_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecct"),
         dictgen::InsensitiveStr::Ascii("eccted"),
@@ -164361,23 +164361,23 @@ pub static WORD_DISCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_DISCOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOL_CHILDREN),
+static WORD_DISCOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sure")],
     values: &[&["disclosure"]],
     range: 4..=4,
 };
 
-static WORD_DISCOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCOG_CHILDREN),
+static WORD_DISCOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rahy"),
         dictgen::InsensitiveStr::Ascii("rapy"),
@@ -164393,12 +164393,12 @@ pub static WORD_DISCOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_DISCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCL_CHILDREN),
+static WORD_DISCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amer"),
         dictgen::InsensitiveStr::Ascii("amier"),
@@ -164426,12 +164426,12 @@ pub static WORD_DISCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_DISCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCI_CHILDREN),
+static WORD_DISCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("menation"),
         dictgen::InsensitiveStr::Ascii("minate"),
@@ -164479,12 +164479,12 @@ pub static WORD_DISCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_DISCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCH_CHILDREN),
+static WORD_DISCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("arded"),
@@ -164498,12 +164498,12 @@ pub static WORD_DISCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DISCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCE_CHILDREN),
+static WORD_DISCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pline"),
         dictgen::InsensitiveStr::Ascii("ption"),
@@ -164519,12 +164519,12 @@ pub static WORD_DISCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DISCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCC_CHILDREN),
+static WORD_DISCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onecct"),
         dictgen::InsensitiveStr::Ascii("oneccted"),
@@ -164596,12 +164596,12 @@ pub static WORD_DISCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DISCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISCA_CHILDREN),
+static WORD_DISCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("limer"),
         dictgen::InsensitiveStr::Ascii("pline"),
@@ -164619,12 +164619,12 @@ pub static WORD_DISCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DISB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISB_CHILDREN),
+static WORD_DISB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -164650,12 +164650,12 @@ pub static WORD_DISB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DISA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DISA_CHILDREN),
+static WORD_DISA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DISA_CHILDREN),
     value: None,
 };
 
-static WORD_DISA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DISA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DISAA_NODE),
     Some(&WORD_DISAB_NODE),
     None,
@@ -164684,12 +164684,12 @@ static WORD_DISA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DISAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAT_CHILDREN),
+static WORD_DISAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erous"),
         dictgen::InsensitiveStr::Ascii("isfaction"),
@@ -164715,12 +164715,12 @@ pub static WORD_DISAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DISAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAS_CHILDREN),
+static WORD_DISAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emble"),
         dictgen::InsensitiveStr::Ascii("embled"),
@@ -164788,12 +164788,12 @@ pub static WORD_DISAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DISAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAR_CHILDREN),
+static WORD_DISAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -164802,12 +164802,12 @@ pub static WORD_DISAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_DISAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAP_CHILDREN),
+static WORD_DISAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ait"),
         dictgen::InsensitiveStr::Ascii("aited"),
@@ -164925,12 +164925,12 @@ pub static WORD_DISAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DISAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAM_CHILDREN),
+static WORD_DISAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bigation"),
         dictgen::InsensitiveStr::Ascii("bigouate"),
@@ -164950,12 +164950,12 @@ pub static WORD_DISAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_DISAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAL_CHILDREN),
+static WORD_DISAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("be"),
@@ -164979,12 +164979,12 @@ pub static WORD_DISAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAG_CHILDREN),
+static WORD_DISAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("red"),
         dictgen::InsensitiveStr::Ascii("reeed"),
@@ -165006,12 +165006,12 @@ pub static WORD_DISAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DISAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAD_CHILDREN),
+static WORD_DISAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("vandage"),
         dictgen::InsensitiveStr::Ascii("vandages"),
@@ -165045,12 +165045,12 @@ pub static WORD_DISAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_DISAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAB_CHILDREN),
+static WORD_DISAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -165096,12 +165096,12 @@ pub static WORD_DISAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DISAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DISAA_CHILDREN),
+static WORD_DISAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DISAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DISAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DISAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("point"),
         dictgen::InsensitiveStr::Ascii("pointed"),
@@ -165110,12 +165110,12 @@ pub static WORD_DISAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIR_CHILDREN),
+static WORD_DIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIR_CHILDREN),
     value: None,
 };
 
-static WORD_DIR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DIRA_NODE),
     Some(&WORD_DIRB_NODE),
     Some(&WORD_DIRC_NODE),
@@ -165144,12 +165144,12 @@ static WORD_DIR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIRV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRV_CHILDREN),
+static WORD_DIRV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -165167,12 +165167,12 @@ pub static WORD_DIRV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_DIRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRT_CHILDREN),
+static WORD_DIRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectory"),
         dictgen::InsensitiveStr::Ascii("yed"),
@@ -165182,12 +165182,12 @@ pub static WORD_DIRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRR_CHILDREN),
+static WORD_DIRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ection"),
         dictgen::InsensitiveStr::Ascii("ectly"),
@@ -165196,34 +165196,34 @@ pub static WORD_DIRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_DIRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRI_CHILDREN),
+static WORD_DIRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ved")],
     values: &[&["derived"]],
     range: 3..=3,
 };
 
-static WORD_DIRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRF_CHILDREN),
+static WORD_DIRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ting")],
     values: &[&["drifting"]],
     range: 4..=4,
 };
 
-static WORD_DIRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIRE_CHILDREN),
+static WORD_DIRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIRE_CHILDREN),
     value: None,
 };
 
-static WORD_DIRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DIREC_NODE),
@@ -165252,23 +165252,23 @@ static WORD_DIRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIREV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREV_CHILDREN),
+static WORD_DIREV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ctory")],
     values: &[&["directory"]],
     range: 5..=5,
 };
 
-static WORD_DIRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRET_CHILDREN),
+static WORD_DIRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRET_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cx"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -165288,23 +165288,23 @@ pub static WORD_DIRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRES_CHILDREN),
+static WORD_DIRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ired")],
     values: &[&["desired"]],
     range: 4..=4,
 };
 
-static WORD_DIRER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRER_CHILDREN),
+static WORD_DIRER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRER_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctor"),
         dictgen::InsensitiveStr::Ascii("ctories"),
@@ -165320,12 +165320,12 @@ pub static WORD_DIRER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_DIREK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREK_CHILDREN),
+static WORD_DIREK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tional"),
         dictgen::InsensitiveStr::Ascii("tly"),
@@ -165334,45 +165334,45 @@ pub static WORD_DIREK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREG_CHILDREN),
+static WORD_DIREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ard")],
     values: &[&["disregard"]],
     range: 3..=3,
 };
 
-static WORD_DIREF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREF_CHILDREN),
+static WORD_DIREF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tory")],
     values: &[&["directory"]],
     range: 4..=4,
 };
 
-static WORD_DIREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIREE_CHILDREN),
+static WORD_DIREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ctly")],
     values: &[&["directly"]],
     range: 4..=4,
 };
 
-static WORD_DIREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIREC_CHILDREN),
+static WORD_DIREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIREC_CHILDREN),
     value: None,
 };
 
-static WORD_DIREC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIREC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DIRECC_NODE),
@@ -165401,12 +165401,12 @@ static WORD_DIREC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIRECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECT_CHILDREN),
+static WORD_DIRECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -165520,23 +165520,23 @@ pub static WORD_DIRECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_DIRECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECR_CHILDREN),
+static WORD_DIRECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["directed"]],
     range: 3..=3,
 };
 
-static WORD_DIRECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECO_CHILDREN),
+static WORD_DIRECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ries"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -165558,12 +165558,12 @@ pub static WORD_DIRECO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_DIRECL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECL_CHILDREN),
+static WORD_DIRECL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ty"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -165572,12 +165572,12 @@ pub static WORD_DIRECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_DIRECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECI_CHILDREN),
+static WORD_DIRECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("on"),
         dictgen::InsensitiveStr::Ascii("onal"),
@@ -165601,12 +165601,12 @@ pub static WORD_DIRECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_DIRECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECE_CHILDREN),
+static WORD_DIRECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tories"),
         dictgen::InsensitiveStr::Ascii("tory"),
@@ -165615,12 +165615,12 @@ pub static WORD_DIRECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_DIRECD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECD_CHILDREN),
+static WORD_DIRECD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ories"),
         dictgen::InsensitiveStr::Ascii("ory"),
@@ -165630,12 +165630,12 @@ pub static WORD_DIRECD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_DIRECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRECC_CHILDREN),
+static WORD_DIRECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ional"),
@@ -165655,12 +165655,12 @@ pub static WORD_DIRECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_DIRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRC_CHILDREN),
+static WORD_DIRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etories"),
@@ -165682,23 +165682,23 @@ pub static WORD_DIRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DIRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRB_CHILDREN),
+static WORD_DIRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ble")],
     values: &[&["dribble"]],
     range: 3..=3,
 };
 
-static WORD_DIRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIRA_CHILDREN),
+static WORD_DIRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tions"),
@@ -165707,23 +165707,23 @@ pub static WORD_DIRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_DIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIQ_CHILDREN),
+static WORD_DIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["dial"]],
     range: 1..=1,
 };
 
-static WORD_DIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIP_CHILDREN),
+static WORD_DIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atch"),
         dictgen::InsensitiveStr::Ascii("ections"),
@@ -165783,12 +165783,12 @@ pub static WORD_DIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_DIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIO_CHILDREN),
+static WORD_DIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("log"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -165808,12 +165808,12 @@ pub static WORD_DIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_DIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIN_CHILDREN),
+static WORD_DIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("amic"),
@@ -165869,12 +165869,12 @@ pub static WORD_DIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_DIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIM_CHILDREN),
+static WORD_DIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("and"),
         dictgen::InsensitiveStr::Ascii("ands"),
@@ -166000,12 +166000,12 @@ pub static WORD_DIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_DIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIL_CHILDREN),
+static WORD_DIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aog"),
         dictgen::InsensitiveStr::Ascii("ema"),
@@ -166037,12 +166037,12 @@ pub static WORD_DIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_DIJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIJ_CHILDREN),
+static WORD_DIJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("skstra"),
         dictgen::InsensitiveStr::Ascii("sktra"),
@@ -166052,12 +166052,12 @@ pub static WORD_DIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_DIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIG_CHILDREN),
+static WORD_DIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anose"),
         dictgen::InsensitiveStr::Ascii("anosed"),
@@ -166103,12 +166103,12 @@ pub static WORD_DIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_DIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIF_CHILDREN),
+static WORD_DIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIF_CHILDREN),
     value: None,
 };
 
-static WORD_DIF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -166137,12 +166137,12 @@ static WORD_DIF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFU_CHILDREN),
+static WORD_DIFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("sed"),
@@ -166160,12 +166160,12 @@ pub static WORD_DIFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFR_CHILDREN),
+static WORD_DIFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -166183,12 +166183,12 @@ pub static WORD_DIFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFI_CHILDREN),
+static WORD_DIFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cult"),
         dictgen::InsensitiveStr::Ascii("culties"),
@@ -166214,12 +166214,12 @@ pub static WORD_DIFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DIFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIFF_CHILDREN),
+static WORD_DIFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIFF_CHILDREN),
     value: None,
 };
 
-static WORD_DIFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIFF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DIFFC_NODE),
@@ -166248,12 +166248,12 @@ static WORD_DIFF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIFFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFU_CHILDREN),
+static WORD_DIFFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("clt"),
         dictgen::InsensitiveStr::Ascii("cult"),
@@ -166277,12 +166277,12 @@ pub static WORD_DIFFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DIFFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFR_CHILDREN),
+static WORD_DIFFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eences"),
         dictgen::InsensitiveStr::Ascii("eent"),
@@ -166316,12 +166316,12 @@ pub static WORD_DIFFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DIFFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFI_CHILDREN),
+static WORD_DIFFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cault"),
         dictgen::InsensitiveStr::Ascii("caulties"),
@@ -166361,12 +166361,12 @@ pub static WORD_DIFFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DIFFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFF_CHILDREN),
+static WORD_DIFFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ered"),
         dictgen::InsensitiveStr::Ascii("erence"),
@@ -166386,12 +166386,12 @@ pub static WORD_DIFFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DIFFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIFFE_CHILDREN),
+static WORD_DIFFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIFFE_CHILDREN),
     value: None,
 };
 
-static WORD_DIFFE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIFFE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -166420,12 +166420,12 @@ static WORD_DIFFE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIFFER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIFFER_CHILDREN),
+static WORD_DIFFER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIFFER_CHILDREN),
     value: None,
 };
 
-static WORD_DIFFER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIFFER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DIFFERA_NODE),
     None,
     None,
@@ -166454,12 +166454,12 @@ static WORD_DIFFER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIFFERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERR_CHILDREN),
+static WORD_DIFFERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -166477,12 +166477,12 @@ pub static WORD_DIFFERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=5,
 };
 
-static WORD_DIFFERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERN_CHILDREN),
+static WORD_DIFFERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -166542,12 +166542,12 @@ pub static WORD_DIFFERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_DIFFERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERI_CHILDREN),
+static WORD_DIFFERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ator"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -166561,12 +166561,12 @@ pub static WORD_DIFFERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 4..=8,
 };
 
-static WORD_DIFFERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERE_CHILDREN),
+static WORD_DIFFERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -166656,12 +166656,12 @@ pub static WORD_DIFFERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=12,
 };
 
-static WORD_DIFFERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERA_CHILDREN),
+static WORD_DIFFERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nce"),
         dictgen::InsensitiveStr::Ascii("nces"),
@@ -166687,12 +166687,12 @@ pub static WORD_DIFFERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_DIFFEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFEN_CHILDREN),
+static WORD_DIFFEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -166716,23 +166716,23 @@ pub static WORD_DIFFEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_DIFFEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFEE_CHILDREN),
+static WORD_DIFFEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nt")],
     values: &[&["different"]],
     range: 2..=2,
 };
 
-static WORD_DIFFC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFFC_CHILDREN),
+static WORD_DIFFC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFFC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFFC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ult"),
         dictgen::InsensitiveStr::Ascii("ulties"),
@@ -166742,12 +166742,12 @@ pub static WORD_DIFFC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIFE_CHILDREN),
+static WORD_DIFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nitly"),
         dictgen::InsensitiveStr::Ascii("rence"),
@@ -166775,12 +166775,12 @@ pub static WORD_DIFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_DIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIE_CHILDREN),
+static WORD_DIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("abled"),
@@ -166814,12 +166814,12 @@ pub static WORD_DIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DID_CHILDREN),
+static WORD_DID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DID_CHILDREN),
     value: None,
 };
 
-pub static WORD_DID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("sapointed"),
@@ -166828,12 +166828,12 @@ pub static WORD_DID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_DIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIC_CHILDREN),
+static WORD_DIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIC_CHILDREN),
     value: None,
 };
 
-static WORD_DIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DICA_NODE),
     None,
     None,
@@ -166862,12 +166862,12 @@ static WORD_DIC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DICU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICU_CHILDREN),
+static WORD_DICU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ss"),
         dictgen::InsensitiveStr::Ascii("ssed"),
@@ -166885,12 +166885,12 @@ pub static WORD_DICU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DICT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICT_CHILDREN),
+static WORD_DICT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adorship"),
         dictgen::InsensitiveStr::Ascii("aionaries"),
@@ -166960,12 +166960,12 @@ pub static WORD_DICT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DICS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICS_CHILDREN),
+static WORD_DICS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("riminated"),
         dictgen::InsensitiveStr::Ascii("uss"),
@@ -166974,12 +166974,12 @@ pub static WORD_DICS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DICR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICR_CHILDREN),
+static WORD_DICR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectory"),
         dictgen::InsensitiveStr::Ascii("ete"),
@@ -167007,12 +167007,12 @@ pub static WORD_DICR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DICO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICO_CHILDREN),
+static WORD_DICO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nnected"),
         dictgen::InsensitiveStr::Ascii("nnection"),
@@ -167042,23 +167042,23 @@ pub static WORD_DICO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DICL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICL_CHILDREN),
+static WORD_DICL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ine")],
     values: &[&["decline"]],
     range: 3..=3,
 };
 
-static WORD_DICK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICK_CHILDREN),
+static WORD_DICK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isch"),
         dictgen::InsensitiveStr::Ascii("sih"),
@@ -167067,12 +167067,12 @@ pub static WORD_DICK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DICI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICI_CHILDREN),
+static WORD_DICI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -167102,12 +167102,12 @@ pub static WORD_DICI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DICH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICH_CHILDREN),
+static WORD_DICH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omoty"),
         dictgen::InsensitiveStr::Ascii("otomoy"),
@@ -167117,23 +167117,23 @@ pub static WORD_DICH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DICE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICE_CHILDREN),
+static WORD_DICE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rgence")],
     values: &[&["divergence"]],
     range: 6..=6,
 };
 
-static WORD_DICA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DICA_CHILDREN),
+static WORD_DICA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DICA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rded"),
@@ -167155,12 +167155,12 @@ pub static WORD_DICA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DIA_CHILDREN),
+static WORD_DIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DIA_CHILDREN),
     value: None,
 };
 
-static WORD_DIA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DIA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DIAA_NODE),
     Some(&WORD_DIAB_NODE),
     Some(&WORD_DIAC_NODE),
@@ -167189,12 +167189,12 @@ static WORD_DIA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DIAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAT_CHILDREN),
+static WORD_DIAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ancing"),
@@ -167203,12 +167203,12 @@ pub static WORD_DIAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DIAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAS_CHILDREN),
+static WORD_DIAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bled"),
@@ -167238,12 +167238,12 @@ pub static WORD_DIAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DIAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAR_CHILDREN),
+static WORD_DIAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("am"),
         dictgen::InsensitiveStr::Ascii("ea"),
@@ -167265,12 +167265,12 @@ pub static WORD_DIAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAP_CHILDREN),
+static WORD_DIAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lay"),
         dictgen::InsensitiveStr::Ascii("lays"),
@@ -167280,12 +167280,12 @@ pub static WORD_DIAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DIAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAN_CHILDREN),
+static WORD_DIAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gose"),
         dictgen::InsensitiveStr::Ascii("ostic"),
@@ -167295,12 +167295,12 @@ pub static WORD_DIAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DIAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAM_CHILDREN),
+static WORD_DIAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ater"),
         dictgen::InsensitiveStr::Ascii("aters"),
@@ -167320,12 +167320,12 @@ pub static WORD_DIAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAL_CHILDREN),
+static WORD_DIAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aog"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -167363,23 +167363,23 @@ pub static WORD_DIAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAH_CHILDREN),
+static WORD_DIAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rrea")],
     values: &[&["diarrhea"]],
     range: 4..=4,
 };
 
-static WORD_DIAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAG_CHILDREN),
+static WORD_DIAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anol"),
         dictgen::InsensitiveStr::Ascii("inal"),
@@ -167457,12 +167457,12 @@ pub static WORD_DIAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DIAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAC_CHILDREN),
+static WORD_DIAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iritc"),
         dictgen::InsensitiveStr::Ascii("iritcs"),
@@ -167471,12 +167471,12 @@ pub static WORD_DIAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_DIAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAB_CHILDREN),
+static WORD_DIAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etees"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -167504,34 +167504,34 @@ pub static WORD_DIAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DIAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DIAA_CHILDREN),
+static WORD_DIAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DIAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DIAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DIAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bled")],
     values: &[&["disabled"]],
     range: 4..=4,
 };
 
-static WORD_DG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DG_CHILDREN),
+static WORD_DG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etttext")],
     values: &[&["dgettext"]],
     range: 7..=7,
 };
 
-static WORD_DF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DF_CHILDREN),
+static WORD_DF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -167549,12 +167549,12 @@ pub static WORD_DF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_DE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DE_CHILDREN),
+static WORD_DE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DE_CHILDREN),
     value: None,
 };
 
-static WORD_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEA_NODE),
     Some(&WORD_DEB_NODE),
     Some(&WORD_DEC_NODE),
@@ -167583,12 +167583,12 @@ static WORD_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEZ_NODE),
 ];
 
-static WORD_DEZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEZ_CHILDREN),
+static WORD_DEZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ember"),
         dictgen::InsensitiveStr::Ascii("entralized"),
@@ -167608,12 +167608,12 @@ pub static WORD_DEZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_DEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEY_CHILDREN),
+static WORD_DEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hdrated"),
         dictgen::InsensitiveStr::Ascii("hdration"),
@@ -167622,23 +167622,23 @@ pub static WORD_DEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_DEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEW_CHILDREN),
+static WORD_DEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rapping")],
     values: &[&["unwrapping"]],
     range: 7..=7,
 };
 
-static WORD_DEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEV_CHILDREN),
+static WORD_DEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEV_CHILDREN),
     value: None,
 };
 
-static WORD_DEV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEVA_NODE),
     None,
     Some(&WORD_DEVC_NODE),
@@ -167667,34 +167667,34 @@ static WORD_DEV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEVY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVY_CHILDREN),
+static WORD_DEVY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVY_CHILDREN),
     value: Some(&["divvy"]),
 };
 
-pub static WORD_DEVY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DEVU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVU_CHILDREN),
+static WORD_DEVU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ce")],
     values: &[&["device"]],
     range: 2..=2,
 };
 
-static WORD_DEVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVR_CHILDREN),
+static WORD_DEVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itualisation"),
         dictgen::InsensitiveStr::Ascii("itualization"),
@@ -167703,12 +167703,12 @@ pub static WORD_DEVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 12..=12,
 };
 
-static WORD_DEVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVO_CHILDREN),
+static WORD_DEVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lopement"),
         dictgen::InsensitiveStr::Ascii("lopments"),
@@ -167730,12 +167730,12 @@ pub static WORD_DEVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DEVL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVL_CHILDREN),
+static WORD_DEVL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eop"),
         dictgen::InsensitiveStr::Ascii("eoped"),
@@ -167783,12 +167783,12 @@ pub static WORD_DEVL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DEVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVI_CHILDREN),
+static WORD_DEVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alet"),
         dictgen::InsensitiveStr::Ascii("atie"),
@@ -167892,12 +167892,12 @@ pub static WORD_DEVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=14,
 };
 
-static WORD_DEVF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVF_CHILDREN),
+static WORD_DEVF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -167907,12 +167907,12 @@ pub static WORD_DEVF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DEVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVE_CHILDREN),
+static WORD_DEVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lepmont"),
         dictgen::InsensitiveStr::Ascii("lepors"),
@@ -168032,12 +168032,12 @@ pub static WORD_DEVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_DEVC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVC_CHILDREN),
+static WORD_DEVC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -168055,12 +168055,12 @@ pub static WORD_DEVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DEVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEVA_CHILDREN),
+static WORD_DEVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("int"),
         dictgen::InsensitiveStr::Ascii("ite"),
@@ -168084,12 +168084,12 @@ pub static WORD_DEVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEU_CHILDREN),
+static WORD_DEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bug"),
         dictgen::InsensitiveStr::Ascii("buging"),
@@ -168121,12 +168121,12 @@ pub static WORD_DEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DET_CHILDREN),
+static WORD_DET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DET_CHILDREN),
     value: None,
 };
 
-static WORD_DET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DET_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DETA_NODE),
     None,
     Some(&WORD_DETC_NODE),
@@ -168155,12 +168155,12 @@ static WORD_DET_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DETU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETU_CHILDREN),
+static WORD_DETU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rance"),
@@ -168170,12 +168170,12 @@ pub static WORD_DETU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DETT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETT_CHILDREN),
+static WORD_DETT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("ached"),
@@ -168185,12 +168185,12 @@ pub static WORD_DETT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DETR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETR_CHILDREN),
+static WORD_DETR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amental"),
         dictgen::InsensitiveStr::Ascii("emental"),
@@ -168230,34 +168230,34 @@ pub static WORD_DETR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DETO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETO_CHILDREN),
+static WORD_DETO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rit")],
     values: &[&["detroit"]],
     range: 3..=3,
 };
 
-static WORD_DETM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETM_CHILDREN),
+static WORD_DETM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atologist")],
     values: &[&["dermatologist"]],
     range: 9..=9,
 };
 
-static WORD_DETI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETI_CHILDREN),
+static WORD_DETI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -168279,12 +168279,12 @@ pub static WORD_DETI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DETE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DETE_CHILDREN),
+static WORD_DETE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DETE_CHILDREN),
     value: None,
 };
 
-static WORD_DETE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DETE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DETEC_NODE),
@@ -168313,12 +168313,12 @@ static WORD_DETE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DETET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETET_CHILDREN),
+static WORD_DETET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETET_CHILDREN),
     value: Some(&["detect", "delete"]),
 };
 
-pub static WORD_DETET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -168340,12 +168340,12 @@ pub static WORD_DETET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_DETER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETER_CHILDREN),
+static WORD_DETER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETER_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("emine"),
@@ -168475,23 +168475,23 @@ pub static WORD_DETER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_DETEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETEO_CHILDREN),
+static WORD_DETEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("riated")],
     values: &[&["deteriorated"]],
     range: 6..=6,
 };
 
-static WORD_DETEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETEM_CHILDREN),
+static WORD_DETEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -168507,12 +168507,12 @@ pub static WORD_DETEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DETEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETEC_CHILDREN),
+static WORD_DETEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eted"),
@@ -168568,12 +168568,12 @@ pub static WORD_DETEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DETC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETC_CHILDREN),
+static WORD_DETC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eting"),
         dictgen::InsensitiveStr::Ascii("etion"),
@@ -168597,12 +168597,12 @@ pub static WORD_DETC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DETA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DETA_CHILDREN),
+static WORD_DETA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DETA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DETA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DETA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("base"),
         dictgen::InsensitiveStr::Ascii("chs"),
@@ -168652,12 +168652,12 @@ pub static WORD_DETA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DES_CHILDREN),
+static WORD_DES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DES_CHILDREN),
     value: None,
 };
 
-static WORD_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DES_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DESA_NODE),
     None,
     Some(&WORD_DESC_NODE),
@@ -168686,12 +168686,12 @@ static WORD_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESY_CHILDREN),
+static WORD_DESY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chronize"),
         dictgen::InsensitiveStr::Ascii("chronized"),
@@ -168700,23 +168700,23 @@ pub static WORD_DESY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_DESU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESU_CHILDREN),
+static WORD_DESU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ction")],
     values: &[&["seduction"]],
     range: 5..=5,
 };
 
-static WORD_DEST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEST_CHILDREN),
+static WORD_DEST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEST_CHILDREN),
     value: None,
 };
 
-static WORD_DEST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DESTA_NODE),
     None,
     None,
@@ -168745,12 +168745,12 @@ static WORD_DEST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTU_CHILDREN),
+static WORD_DESTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -168778,23 +168778,23 @@ pub static WORD_DESTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DESTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTT_CHILDREN),
+static WORD_DESTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ructor")],
     values: &[&["destructor"]],
     range: 6..=6,
 };
 
-static WORD_DESTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTR_CHILDREN),
+static WORD_DESTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("action"),
         dictgen::InsensitiveStr::Ascii("actions"),
@@ -168900,12 +168900,12 @@ pub static WORD_DESTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DESTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTO_CHILDREN),
+static WORD_DESTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("ps"),
@@ -168941,12 +168941,12 @@ pub static WORD_DESTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_DESTK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTK_CHILDREN),
+static WORD_DESTK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("op"),
         dictgen::InsensitiveStr::Ascii("ops"),
@@ -168955,12 +168955,12 @@ pub static WORD_DESTK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_DESTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTI_CHILDREN),
+static WORD_DESTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antion"),
         dictgen::InsensitiveStr::Ascii("antions"),
@@ -169032,23 +169032,23 @@ pub static WORD_DESTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DESTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTE_CHILDREN),
+static WORD_DESTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ctor")],
     values: &[&["detector"]],
     range: 4..=4,
 };
 
-static WORD_DESTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESTA_CHILDREN),
+static WORD_DESTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blized"),
         dictgen::InsensitiveStr::Ascii("nation"),
@@ -169064,12 +169064,12 @@ pub static WORD_DESTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DESS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESS_CHILDREN),
+static WORD_DESS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cribe"),
         dictgen::InsensitiveStr::Ascii("cribing"),
@@ -169095,12 +169095,12 @@ pub static WORD_DESS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_DESR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESR_CHILDREN),
+static WORD_DESR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciption"),
         dictgen::InsensitiveStr::Ascii("ciptions"),
@@ -169138,23 +169138,23 @@ pub static WORD_DESR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DESQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESQ_CHILDREN),
+static WORD_DESQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ualified")],
     values: &[&["disqualified"]],
     range: 8..=8,
 };
 
-static WORD_DESP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESP_CHILDREN),
+static WORD_DESP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("arately"),
@@ -169220,12 +169220,12 @@ pub static WORD_DESP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DESO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESO_CHILDREN),
+static WORD_DESO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("gned"),
@@ -169251,12 +169251,12 @@ pub static WORD_DESO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DESN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESN_CHILDREN),
+static WORD_DESN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -169272,12 +169272,12 @@ pub static WORD_DESN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_DESL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESL_CHILDREN),
+static WORD_DESL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -169288,12 +169288,12 @@ pub static WORD_DESL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DESK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESK_CHILDREN),
+static WORD_DESK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("op"),
         dictgen::InsensitiveStr::Ascii("ops"),
@@ -169313,12 +169313,12 @@ pub static WORD_DESK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DESI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESI_CHILDREN),
+static WORD_DESI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("cate"),
@@ -169444,12 +169444,12 @@ pub static WORD_DESI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_DESG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESG_CHILDREN),
+static WORD_DESG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("inated"),
@@ -169477,12 +169477,12 @@ pub static WORD_DESG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DESE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESE_CHILDREN),
+static WORD_DESE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lct"),
         dictgen::InsensitiveStr::Ascii("lctable"),
@@ -169564,12 +169564,12 @@ pub static WORD_DESE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_DESC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DESC_CHILDREN),
+static WORD_DESC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DESC_CHILDREN),
     value: None,
 };
 
-static WORD_DESC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DESC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DESCA_NODE),
     None,
     Some(&WORD_DESCC_NODE),
@@ -169598,12 +169598,12 @@ static WORD_DESC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESCV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCV_CHILDREN),
+static WORD_DESCV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ription"),
         dictgen::InsensitiveStr::Ascii("riptions"),
@@ -169612,23 +169612,23 @@ pub static WORD_DESCV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_DESCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCU_CHILDREN),
+static WORD_DESCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ss")],
     values: &[&["discuss"]],
     range: 2..=2,
 };
 
-static WORD_DESCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCT_CHILDREN),
+static WORD_DESCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iption"),
         dictgen::InsensitiveStr::Ascii("iptions"),
@@ -169658,12 +169658,12 @@ pub static WORD_DESCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DESCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DESCR_CHILDREN),
+static WORD_DESCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DESCR_CHILDREN),
     value: None,
 };
 
-static WORD_DESCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DESCR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DESCRB_NODE),
     None,
@@ -169692,12 +169692,12 @@ static WORD_DESCR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESCRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRY_CHILDREN),
+static WORD_DESCRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("bing"),
@@ -169713,23 +169713,23 @@ pub static WORD_DESCRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_DESCRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRU_CHILDREN),
+static WORD_DESCRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tor")],
     values: &[&["destructor"]],
     range: 3..=3,
 };
 
-static WORD_DESCRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRT_CHILDREN),
+static WORD_DESCRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iption"),
         dictgen::InsensitiveStr::Ascii("iptions"),
@@ -169738,12 +169738,12 @@ pub static WORD_DESCRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=7,
 };
 
-static WORD_DESCRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRP_CHILDREN),
+static WORD_DESCRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -169761,12 +169761,12 @@ pub static WORD_DESCRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_DESCRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DESCRI_CHILDREN),
+static WORD_DESCRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DESCRI_CHILDREN),
     value: None,
 };
 
-static WORD_DESCRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DESCRI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DESCRIB_NODE),
     Some(&WORD_DESCRIC_NODE),
@@ -169795,12 +169795,12 @@ static WORD_DESCRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DESCRIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIV_CHILDREN),
+static WORD_DESCRIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -169809,12 +169809,12 @@ pub static WORD_DESCRIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=3,
 };
 
-static WORD_DESCRIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIT_CHILDREN),
+static WORD_DESCRIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("or"),
@@ -169858,23 +169858,23 @@ pub static WORD_DESCRIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_DESCRIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIS_CHILDREN),
+static WORD_DESCRIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["describes"]],
     range: 1..=1,
 };
 
-static WORD_DESCRIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIP_CHILDREN),
+static WORD_DESCRIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cion"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -169942,12 +169942,12 @@ pub static WORD_DESCRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_DESCRIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIO_CHILDREN),
+static WORD_DESCRIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -169957,12 +169957,12 @@ pub static WORD_DESCRIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_DESCRIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIM_CHILDREN),
+static WORD_DESCRIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inant"),
         dictgen::InsensitiveStr::Ascii("inate"),
@@ -169984,34 +169984,34 @@ pub static WORD_DESCRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=7,
 };
 
-static WORD_DESCRII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRII_CHILDREN),
+static WORD_DESCRII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRII_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bes")],
     values: &[&["describes"]],
     range: 3..=3,
 };
 
-static WORD_DESCRIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIE_CHILDREN),
+static WORD_DESCRIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIE_CHILDREN),
     value: Some(&["describe"]),
 };
 
-pub static WORD_DESCRIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DESCRIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIC_CHILDREN),
+static WORD_DESCRIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -170027,12 +170027,12 @@ pub static WORD_DESCRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_DESCRIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIB_CHILDREN),
+static WORD_DESCRIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRIB_CHILDREN),
     value: Some(&["describe"]),
 };
 
-pub static WORD_DESCRIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bed"),
         dictgen::InsensitiveStr::Ascii("ibg"),
@@ -170054,12 +170054,12 @@ pub static WORD_DESCRIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_DESCRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRE_CHILDREN),
+static WORD_DESCRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -170083,34 +170083,34 @@ pub static WORD_DESCRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_DESCRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCRB_CHILDREN),
+static WORD_DESCRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["describes"]],
     range: 2..=2,
 };
 
-static WORD_DESCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCP_CHILDREN),
+static WORD_DESCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rition")],
     values: &[&["descriptions"]],
     range: 6..=6,
 };
 
-static WORD_DESCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCO_CHILDREN),
+static WORD_DESCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nstructed"),
         dictgen::InsensitiveStr::Ascii("ver"),
@@ -170128,12 +170128,12 @@ pub static WORD_DESCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DESCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCK_CHILDREN),
+static WORD_DESCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("top"),
         dictgen::InsensitiveStr::Ascii("tops"),
@@ -170142,12 +170142,12 @@ pub static WORD_DESCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DESCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCI_CHILDREN),
+static WORD_DESCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("bed"),
@@ -170217,12 +170217,12 @@ pub static WORD_DESCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DESCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCE_CHILDREN),
+static WORD_DESCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dent"),
         dictgen::InsensitiveStr::Ascii("ncing"),
@@ -170256,12 +170256,12 @@ pub static WORD_DESCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DESCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCC_CHILDREN),
+static WORD_DESCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hedules"),
         dictgen::InsensitiveStr::Ascii("ription"),
@@ -170270,12 +170270,12 @@ pub static WORD_DESCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=7,
 };
 
-static WORD_DESCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESCA_CHILDREN),
+static WORD_DESCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llocate"),
         dictgen::InsensitiveStr::Ascii("llocated"),
@@ -170293,12 +170293,12 @@ pub static WORD_DESCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_DESA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DESA_CHILDREN),
+static WORD_DESA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DESA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DESA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctivate"),
         dictgen::InsensitiveStr::Ascii("ctivated"),
@@ -170318,12 +170318,12 @@ pub static WORD_DESA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_DER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DER_CHILDREN),
+static WORD_DER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DER_CHILDREN),
     value: None,
 };
 
-static WORD_DER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DERA_NODE),
     None,
     None,
@@ -170352,12 +170352,12 @@ static WORD_DER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERY_CHILDREN),
+static WORD_DERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("pted"),
@@ -170367,12 +170367,12 @@ pub static WORD_DERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERV_CHILDREN),
+static WORD_DERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iative"),
         dictgen::InsensitiveStr::Ascii("iatives"),
@@ -170394,23 +170394,23 @@ pub static WORD_DERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DERU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERU_CHILDREN),
+static WORD_DERU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gulation")],
     values: &[&["deregulation"]],
     range: 8..=8,
 };
 
-static WORD_DERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERT_CHILDREN),
+static WORD_DERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ails"),
         dictgen::InsensitiveStr::Ascii("ermine"),
@@ -170428,12 +170428,12 @@ pub static WORD_DERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERR_CHILDREN),
+static WORD_DERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ivatives"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -170443,12 +170443,12 @@ pub static WORD_DERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DERP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERP_CHILDREN),
+static WORD_DERP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atologist"),
         dictgen::InsensitiveStr::Ascii("ivation"),
@@ -170458,12 +170458,12 @@ pub static WORD_DERP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_DERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERO_CHILDREN),
+static WORD_DERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gatary"),
         dictgen::InsensitiveStr::Ascii("gatery"),
@@ -170483,23 +170483,23 @@ pub static WORD_DERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_DERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERN_CHILDREN),
+static WORD_DERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ormalization")],
     values: &[&["denormalization"]],
     range: 12..=12,
 };
 
-static WORD_DERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERM_CHILDREN),
+static WORD_DERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atalogist"),
         dictgen::InsensitiveStr::Ascii("atolagist"),
@@ -170527,12 +170527,12 @@ pub static WORD_DERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_DERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERI_CHILDREN),
+static WORD_DERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("air"),
         dictgen::InsensitiveStr::Ascii("atives"),
@@ -170588,12 +170588,12 @@ pub static WORD_DERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERG_CHILDREN),
+static WORD_DERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eistered"),
         dictgen::InsensitiveStr::Ascii("istration"),
@@ -170602,12 +170602,12 @@ pub static WORD_DERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_DERF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERF_CHILDREN),
+static WORD_DERF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erence"),
         dictgen::InsensitiveStr::Ascii("erencing"),
@@ -170627,12 +170627,12 @@ pub static WORD_DERF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERE_CHILDREN),
+static WORD_DERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ction"),
         dictgen::InsensitiveStr::Ascii("ctive"),
@@ -170740,12 +170740,12 @@ pub static WORD_DERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_DERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DERA_CHILDREN),
+static WORD_DERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("geable"),
         dictgen::InsensitiveStr::Ascii("gotory"),
@@ -170755,12 +170755,12 @@ pub static WORD_DERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEQ_CHILDREN),
+static WORD_DEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ued"),
         dictgen::InsensitiveStr::Ascii("ueing"),
@@ -170769,12 +170769,12 @@ pub static WORD_DEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_DEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEP_CHILDREN),
+static WORD_DEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEP_CHILDREN),
     value: None,
 };
 
-static WORD_DEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEPA_NODE),
     None,
     Some(&WORD_DEPC_NODE),
@@ -170803,12 +170803,12 @@ static WORD_DEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPS_CHILDREN),
+static WORD_DEPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("awn"),
         dictgen::InsensitiveStr::Ascii("erate"),
@@ -170830,12 +170830,12 @@ pub static WORD_DEPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DEPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPR_CHILDREN),
+static WORD_DEPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acated"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -170941,12 +170941,12 @@ pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DEPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPO_CHILDREN),
+static WORD_DEPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ist"),
         dictgen::InsensitiveStr::Ascii("isted"),
@@ -170992,12 +170992,12 @@ pub static WORD_DEPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DEPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPN_CHILDREN),
+static WORD_DEPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dant"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -171007,12 +171007,12 @@ pub static WORD_DEPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_DEPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPL_CHILDREN),
+static WORD_DEPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acements"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -171058,12 +171058,12 @@ pub static WORD_DEPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DEPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPI_CHILDREN),
+static WORD_DEPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("citng"),
         dictgen::InsensitiveStr::Ascii("citon"),
@@ -171083,12 +171083,12 @@ pub static WORD_DEPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DEPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEPE_CHILDREN),
+static WORD_DEPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEPE_CHILDREN),
     value: None,
 };
 
-static WORD_DEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DEPEC_NODE),
@@ -171117,12 +171117,12 @@ static WORD_DEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPER_CHILDREN),
+static WORD_DEPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -171146,12 +171146,12 @@ pub static WORD_DEPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_DEPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEPEN_CHILDREN),
+static WORD_DEPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEPEN_CHILDREN),
     value: None,
 };
 
-static WORD_DEPEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEPEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEPENA_NODE),
     None,
     Some(&WORD_DEPENC_NODE),
@@ -171180,45 +171180,45 @@ static WORD_DEPEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEPENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENT_CHILDREN),
+static WORD_DEPENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENT_CHILDREN),
     value: Some(&["depend"]),
 };
 
-pub static WORD_DEPENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DEPENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENN_CHILDREN),
+static WORD_DEPENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ding")],
     values: &[&["depending"]],
     range: 4..=4,
 };
 
-static WORD_DEPENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENI_CHILDREN),
+static WORD_DEPENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["depending", "deepening"]],
     range: 2..=2,
 };
 
-static WORD_DEPENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENE_CHILDREN),
+static WORD_DEPENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("decies"),
@@ -171264,12 +171264,12 @@ pub static WORD_DEPENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_DEPEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPEND_CHILDREN),
+static WORD_DEPEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancey"),
         dictgen::InsensitiveStr::Ascii("ancies"),
@@ -171389,12 +171389,12 @@ pub static WORD_DEPEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_DEPENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENC_CHILDREN),
+static WORD_DEPENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encies"),
         dictgen::InsensitiveStr::Ascii("ency"),
@@ -171418,34 +171418,34 @@ pub static WORD_DEPENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_DEPENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPENA_CHILDREN),
+static WORD_DEPENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ncy")],
     values: &[&["dependency"]],
     range: 3..=3,
 };
 
-static WORD_DEPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPEL_CHILDREN),
+static WORD_DEPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ted")],
     values: &[&["depleted"]],
     range: 3..=3,
 };
 
-static WORD_DEPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPED_CHILDREN),
+static WORD_DEPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("encies"),
         dictgen::InsensitiveStr::Ascii("ency"),
@@ -171463,12 +171463,12 @@ pub static WORD_DEPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DEPEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPEC_CHILDREN),
+static WORD_DEPEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("reated"),
@@ -171478,12 +171478,12 @@ pub static WORD_DEPEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DEPD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPD_CHILDREN),
+static WORD_DEPD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -171563,12 +171563,12 @@ pub static WORD_DEPD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DEPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPC_CHILDREN),
+static WORD_DEPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ited"),
         dictgen::InsensitiveStr::Ascii("iting"),
@@ -171588,12 +171588,12 @@ pub static WORD_DEPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DEPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEPA_CHILDREN),
+static WORD_DEPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndance"),
         dictgen::InsensitiveStr::Ascii("ndancies"),
@@ -171631,12 +171631,12 @@ pub static WORD_DEPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_DEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEO_CHILDREN),
+static WORD_DEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cde"),
         dictgen::InsensitiveStr::Ascii("cded"),
@@ -171688,12 +171688,12 @@ pub static WORD_DEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_DEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEN_CHILDREN),
+static WORD_DEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("codings"),
         dictgen::InsensitiveStr::Ascii("egerate"),
@@ -171793,12 +171793,12 @@ pub static WORD_DEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_DEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEM_CHILDREN),
+static WORD_DEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEM_CHILDREN),
     value: None,
 };
 
-static WORD_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEMA_NODE),
     None,
     Some(&WORD_DEMC_NODE),
@@ -171827,45 +171827,45 @@ static WORD_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMU_CHILDREN),
+static WORD_DEMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dulator")],
     values: &[&["demodulator"]],
     range: 7..=7,
 };
 
-static WORD_DEMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMS_CHILDREN),
+static WORD_DEMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ond")],
     values: &[&["desmond"]],
     range: 3..=3,
 };
 
-static WORD_DEMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMP_CHILDREN),
+static WORD_DEMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hasize")],
     values: &[&["deemphasize"]],
     range: 6..=6,
 };
 
-static WORD_DEMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEMO_CHILDREN),
+static WORD_DEMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEMO_CHILDREN),
     value: None,
 };
 
-static WORD_DEMO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEMO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DEMOC_NODE),
@@ -171894,12 +171894,12 @@ static WORD_DEMO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEMOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOS_CHILDREN),
+static WORD_DEMOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntrably"),
         dictgen::InsensitiveStr::Ascii("ntrate"),
@@ -171931,23 +171931,23 @@ pub static WORD_DEMOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_DEMOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOR_CHILDREN),
+static WORD_DEMOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cracy")],
     values: &[&["democracy"]],
     range: 5..=5,
 };
 
-static WORD_DEMON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMON_CHILDREN),
+static WORD_DEMON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMON_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ination"),
@@ -172031,12 +172031,12 @@ pub static WORD_DEMON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_DEMOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOL_CHILDREN),
+static WORD_DEMOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("icion"),
@@ -172062,12 +172062,12 @@ pub static WORD_DEMOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DEMOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOG_CHILDREN),
+static WORD_DEMOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOG_CHILDREN),
     value: Some(&["demo"]),
 };
 
-pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rahic"),
         dictgen::InsensitiveStr::Ascii("rahpic"),
@@ -172095,23 +172095,23 @@ pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_DEMOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOD_CHILDREN),
+static WORD_DEMOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ualtor")],
     values: &[&["demodulator"]],
     range: 6..=6,
 };
 
-static WORD_DEMOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMOC_CHILDREN),
+static WORD_DEMOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arcies"),
         dictgen::InsensitiveStr::Ascii("arcy"),
@@ -172157,23 +172157,23 @@ pub static WORD_DEMOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DEMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMM_CHILDREN),
+static WORD_DEMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("angled")],
     values: &[&["demangled"]],
     range: 6..=6,
 };
 
-static WORD_DEMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMI_CHILDREN),
+static WORD_DEMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nsion"),
         dictgen::InsensitiveStr::Ascii("nsional"),
@@ -172189,12 +172189,12 @@ pub static WORD_DEMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_DEME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEME_CHILDREN),
+static WORD_DEME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEME_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("naor"),
         dictgen::InsensitiveStr::Ascii("nor"),
@@ -172222,23 +172222,23 @@ pub static WORD_DEME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DEMC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMC_CHILDREN),
+static WORD_DEMC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orats")],
     values: &[&["democrats"]],
     range: 5..=5,
 };
 
-static WORD_DEMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEMA_CHILDREN),
+static WORD_DEMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ind"),
         dictgen::InsensitiveStr::Ascii("md"),
@@ -172258,12 +172258,12 @@ pub static WORD_DEMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEL_CHILDREN),
+static WORD_DEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEL_CHILDREN),
     value: None,
 };
 
-static WORD_DEL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DELA_NODE),
     None,
     Some(&WORD_DELC_NODE),
@@ -172292,23 +172292,23 @@ static WORD_DEL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DELY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELY_CHILDREN),
+static WORD_DELY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aing")],
     values: &[&["delaying"]],
     range: 4..=4,
 };
 
-static WORD_DELV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELV_CHILDREN),
+static WORD_DELV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ery"),
         dictgen::InsensitiveStr::Ascii("iered"),
@@ -172318,12 +172318,12 @@ pub static WORD_DELV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DELU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELU_CHILDREN),
+static WORD_DELU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sionally"),
         dictgen::InsensitiveStr::Ascii("sionnal"),
@@ -172333,12 +172333,12 @@ pub static WORD_DELU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_DELT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELT_CHILDREN),
+static WORD_DELT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELT_CHILDREN),
     value: Some(&["dealt"]),
 };
 
-pub static WORD_DELT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -172356,12 +172356,12 @@ pub static WORD_DELT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_DELP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELP_CHILDREN),
+static WORD_DELP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eted"),
         dictgen::InsensitiveStr::Ascii("orable"),
@@ -172383,34 +172383,34 @@ pub static WORD_DELP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DELO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELO_CHILDREN),
+static WORD_DELO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pyment")],
     values: &[&["deployment"]],
     range: 6..=6,
 };
 
-static WORD_DELL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELL_CHILDREN),
+static WORD_DELL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ocate")],
     values: &[&["deallocate"]],
     range: 5..=5,
 };
 
-static WORD_DELI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DELI_CHILDREN),
+static WORD_DELI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DELI_CHILDREN),
     value: None,
 };
 
-static WORD_DELI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DELI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_DELIB_NODE),
     Some(&WORD_DELIC_NODE),
@@ -172439,12 +172439,12 @@ static WORD_DELI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DELIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIV_CHILDREN),
+static WORD_DELIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ared"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -172482,23 +172482,23 @@ pub static WORD_DELIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DELIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIN_CHILDREN),
+static WORD_DELIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["unlink"]],
     range: 1..=1,
 };
 
-static WORD_DELIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIM_CHILDREN),
+static WORD_DELIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eted"),
         dictgen::InsensitiveStr::Ascii("eter"),
@@ -172578,12 +172578,12 @@ pub static WORD_DELIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_DELIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIG_CHILDREN),
+static WORD_DELIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("htlful"),
@@ -172593,12 +172593,12 @@ pub static WORD_DELIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DELIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIE_CHILDREN),
+static WORD_DELIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ver"),
         dictgen::InsensitiveStr::Ascii("vere"),
@@ -172624,23 +172624,23 @@ pub static WORD_DELIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DELIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIC_CHILDREN),
+static WORD_DELIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ous")],
     values: &[&["delicious"]],
     range: 3..=3,
 };
 
-static WORD_DELIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELIB_CHILDREN),
+static WORD_DELIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("aretely"),
@@ -172680,12 +172680,12 @@ pub static WORD_DELIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DELG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELG_CHILDREN),
+static WORD_DELG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -172709,12 +172709,12 @@ pub static WORD_DELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DELF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELF_CHILDREN),
+static WORD_DELF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ect"),
@@ -172724,12 +172724,12 @@ pub static WORD_DELF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DELE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELE_CHILDREN),
+static WORD_DELE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arship"),
         dictgen::InsensitiveStr::Ascii("arships"),
@@ -172797,12 +172797,12 @@ pub static WORD_DELE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DELC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELC_CHILDREN),
+static WORD_DELC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("arations"),
@@ -172826,12 +172826,12 @@ pub static WORD_DELC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DELA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DELA_CHILDREN),
+static WORD_DELA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DELA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DELA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DELA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ership"),
         dictgen::InsensitiveStr::Ascii("erships"),
@@ -172873,12 +172873,12 @@ pub static WORD_DELA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEK_CHILDREN),
+static WORD_DEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ete"),
         dictgen::InsensitiveStr::Ascii("eted"),
@@ -172904,12 +172904,12 @@ pub static WORD_DEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_DEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEI_CHILDREN),
+static WORD_DEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fnately"),
         dictgen::InsensitiveStr::Ascii("fne"),
@@ -172991,12 +172991,12 @@ pub static WORD_DEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_DEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEH_CHILDREN),
+static WORD_DEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ydraded"),
         dictgen::InsensitiveStr::Ascii("yrdated"),
@@ -173006,12 +173006,12 @@ pub static WORD_DEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_DEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEG_CHILDREN),
+static WORD_DEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arde"),
         dictgen::InsensitiveStr::Ascii("arded"),
@@ -173125,12 +173125,12 @@ pub static WORD_DEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_DEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEF_CHILDREN),
+static WORD_DEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEF_CHILDREN),
     value: None,
 };
 
-static WORD_DEF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEFA_NODE),
     None,
     None,
@@ -173159,23 +173159,23 @@ static WORD_DEF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEFY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFY_CHILDREN),
+static WORD_DEFY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ning")],
     values: &[&["defining"]],
     range: 4..=4,
 };
 
-static WORD_DEFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFU_CHILDREN),
+static WORD_DEFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alt"),
         dictgen::InsensitiveStr::Ascii("altdict"),
@@ -173199,45 +173199,45 @@ pub static WORD_DEFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DEFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFR_CHILDREN),
+static WORD_DEFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("agmenation")],
     values: &[&["defragmentation"]],
     range: 10..=10,
 };
 
-static WORD_DEFQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFQ_CHILDREN),
+static WORD_DEFQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ault")],
     values: &[&["default"]],
     range: 4..=4,
 };
 
-static WORD_DEFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFO_CHILDREN),
+static WORD_DEFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("re")],
     values: &[&["before"]],
     range: 2..=2,
 };
 
-static WORD_DEFN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFN_CHILDREN),
+static WORD_DEFN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("iately"),
@@ -173259,12 +173259,12 @@ pub static WORD_DEFN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DEFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFL_CHILDREN),
+static WORD_DEFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("action"),
         dictgen::InsensitiveStr::Ascii("atin"),
@@ -173288,12 +173288,12 @@ pub static WORD_DEFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DEFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEFI_CHILDREN),
+static WORD_DEFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEFI_CHILDREN),
     value: None,
 };
 
-static WORD_DEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEFI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEFIA_NODE),
     Some(&WORD_DEFIB_NODE),
     Some(&WORD_DEFIC_NODE),
@@ -173322,23 +173322,23 @@ static WORD_DEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEFIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIV_CHILDREN),
+static WORD_DEFIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["derived"]],
     range: 2..=2,
 };
 
-static WORD_DEFIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIT_CHILDREN),
+static WORD_DEFIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enly"),
         dictgen::InsensitiveStr::Ascii("inly"),
@@ -173360,12 +173360,12 @@ pub static WORD_DEFIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DEFIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIS_CHILDREN),
+static WORD_DEFIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hant"),
         dictgen::InsensitiveStr::Ascii("hantly"),
@@ -173374,12 +173374,12 @@ pub static WORD_DEFIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_DEFIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEFIN_CHILDREN),
+static WORD_DEFIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEFIN_CHILDREN),
     value: Some(&["define"]),
 };
 
-static WORD_DEFIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEFIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DEFINA_NODE),
     None,
     None,
@@ -173408,23 +173408,23 @@ static WORD_DEFIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEFINU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINU_CHILDREN),
+static WORD_DEFINU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tely")],
     values: &[&["definitely"]],
     range: 4..=4,
 };
 
-static WORD_DEFINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINT_CHILDREN),
+static WORD_DEFINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINT_CHILDREN),
     value: Some(&["definite", "define"]),
 };
 
-pub static WORD_DEFINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aley"),
         dictgen::InsensitiveStr::Ascii("aly"),
@@ -173462,34 +173462,34 @@ pub static WORD_DEFINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_DEFINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINS_CHILDREN),
+static WORD_DEFINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINS_CHILDREN),
     value: Some(&["defines", "define"]),
 };
 
-pub static WORD_DEFINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tely")],
     values: &[&["definitely"]],
     range: 4..=4,
 };
 
-static WORD_DEFINO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINO_CHILDREN),
+static WORD_DEFINO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINO_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tely")],
     values: &[&["definitely"]],
     range: 4..=4,
 };
 
-static WORD_DEFINN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINN_CHILDREN),
+static WORD_DEFINN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ition"),
@@ -173498,23 +173498,23 @@ pub static WORD_DEFINN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_DEFINM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINM_CHILDREN),
+static WORD_DEFINM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["defined"]],
     range: 2..=2,
 };
 
-static WORD_DEFINL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINL_CHILDREN),
+static WORD_DEFINL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tely"),
         dictgen::InsensitiveStr::Ascii("tey"),
@@ -173523,23 +173523,23 @@ pub static WORD_DEFINL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_DEFINJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINJ_CHILDREN),
+static WORD_DEFINJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tely")],
     values: &[&["definitely"]],
     range: 4..=4,
 };
 
-static WORD_DEFINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINI_CHILDREN),
+static WORD_DEFINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -173665,12 +173665,12 @@ pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_DEFINE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINE_CHILDREN),
+static WORD_DEFINE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("as"),
@@ -173722,12 +173722,12 @@ pub static WORD_DEFINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_DEFIND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIND_CHILDREN),
+static WORD_DEFIND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIND_CHILDREN),
     value: Some(&["defined", "defund"]),
 };
 
-pub static WORD_DEFIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -173741,12 +173741,12 @@ pub static WORD_DEFIND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_DEFINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFINA_CHILDREN),
+static WORD_DEFINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("etly"),
@@ -173812,23 +173812,23 @@ pub static WORD_DEFINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_DEFII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFII_CHILDREN),
+static WORD_DEFII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFII_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ntely")],
     values: &[&["definitely"]],
     range: 5..=5,
 };
 
-static WORD_DEFIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIE_CHILDREN),
+static WORD_DEFIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nd"),
@@ -173839,12 +173839,12 @@ pub static WORD_DEFIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_DEFIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIC_CHILDREN),
+static WORD_DEFIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ately"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -173884,23 +173884,23 @@ pub static WORD_DEFIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_DEFIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIB_CHILDREN),
+static WORD_DEFIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ately")],
     values: &[&["definitely"]],
     range: 5..=5,
 };
 
-static WORD_DEFIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFIA_CHILDREN),
+static WORD_DEFIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("netly"),
         dictgen::InsensitiveStr::Ascii("nlty"),
@@ -173916,12 +173916,12 @@ pub static WORD_DEFIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_DEFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFF_CHILDREN),
+static WORD_DEFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("aulted"),
@@ -173969,12 +173969,12 @@ pub static WORD_DEFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DEFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFE_CHILDREN),
+static WORD_DEFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("aulted"),
@@ -174098,12 +174098,12 @@ pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DEFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEFA_CHILDREN),
+static WORD_DEFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cation"),
         dictgen::InsensitiveStr::Ascii("il"),
@@ -174233,12 +174233,12 @@ pub static WORD_DEFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_DEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEE_CHILDREN),
+static WORD_DEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("corator"),
         dictgen::InsensitiveStr::Ascii("emed"),
@@ -174268,12 +174268,12 @@ pub static WORD_DEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DED_CHILDREN),
+static WORD_DED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DED_CHILDREN),
     value: Some(&["dead"]),
 };
 
-pub static WORD_DED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("ecated"),
@@ -174365,12 +174365,12 @@ pub static WORD_DED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_DEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEC_CHILDREN),
+static WORD_DEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEC_CHILDREN),
     value: None,
 };
 
-static WORD_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DECA_NODE),
     None,
     Some(&WORD_DECC_NODE),
@@ -174399,12 +174399,12 @@ static WORD_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DECY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECY_CHILDREN),
+static WORD_DECY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pher"),
         dictgen::InsensitiveStr::Ascii("phered"),
@@ -174415,12 +174415,12 @@ pub static WORD_DECY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DECU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECU_CHILDREN),
+static WORD_DECU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("table"),
         dictgen::InsensitiveStr::Ascii("tables"),
@@ -174429,12 +174429,12 @@ pub static WORD_DECU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_DECT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECT_CHILDREN),
+static WORD_DECT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ecte"),
@@ -174462,12 +174462,12 @@ pub static WORD_DECT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DECS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECS_CHILDREN),
+static WORD_DECS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cription"),
         dictgen::InsensitiveStr::Ascii("end"),
@@ -174501,12 +174501,12 @@ pub static WORD_DECS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DECR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECR_CHILDREN),
+static WORD_DECR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aesing"),
         dictgen::InsensitiveStr::Ascii("asing"),
@@ -174618,12 +174618,12 @@ pub static WORD_DECR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DECP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECP_CHILDREN),
+static WORD_DECP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etion"),
         dictgen::InsensitiveStr::Ascii("etive"),
@@ -174633,12 +174633,12 @@ pub static WORD_DECP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_DECO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DECO_CHILDREN),
+static WORD_DECO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DECO_CHILDREN),
     value: None,
 };
 
-static WORD_DECO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DECO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DECOA_NODE),
     None,
     Some(&WORD_DECOC_NODE),
@@ -174667,23 +174667,23 @@ static WORD_DECO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DECOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOT_CHILDREN),
+static WORD_DECOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ations")],
     values: &[&["decorations"]],
     range: 6..=6,
 };
 
-static WORD_DECOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOS_CHILDREN),
+static WORD_DECOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -174705,12 +174705,12 @@ pub static WORD_DECOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_DECOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOR_CHILDREN),
+static WORD_DECOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -174762,12 +174762,12 @@ pub static WORD_DECOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DECOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOP_CHILDREN),
+static WORD_DECOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ose"),
         dictgen::InsensitiveStr::Ascii("oses"),
@@ -174777,12 +174777,12 @@ pub static WORD_DECOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_DECON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECON_CHILDREN),
+static WORD_DECON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECON_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("de"),
@@ -174812,12 +174812,12 @@ pub static WORD_DECON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DECOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOM_CHILDREN),
+static WORD_DECOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iler"),
         dictgen::InsensitiveStr::Ascii("issioned"),
@@ -174889,12 +174889,12 @@ pub static WORD_DECOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_DECOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOD_CHILDREN),
+static WORD_DECOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ded"),
         dictgen::InsensitiveStr::Ascii("ding"),
@@ -174904,12 +174904,12 @@ pub static WORD_DECOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DECOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOC_CHILDREN),
+static WORD_DECOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -174931,34 +174931,34 @@ pub static WORD_DECOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_DECOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECOA_CHILDREN),
+static WORD_DECOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rtions")],
     values: &[&["decoration"]],
     range: 6..=6,
 };
 
-static WORD_DECM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECM_CHILDREN),
+static WORD_DECM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eber")],
     values: &[&["december"]],
     range: 4..=4,
 };
 
-static WORD_DECL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECL_CHILDREN),
+static WORD_DECL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("air"),
         dictgen::InsensitiveStr::Ascii("aire"),
@@ -175084,12 +175084,12 @@ pub static WORD_DECL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DECI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECI_CHILDREN),
+static WORD_DECI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aml"),
         dictgen::InsensitiveStr::Ascii("amls"),
@@ -175173,12 +175173,12 @@ pub static WORD_DECI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_DECE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECE_CHILDREN),
+static WORD_DECE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("laration"),
@@ -175238,23 +175238,23 @@ pub static WORD_DECE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DECD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECD_CHILDREN),
+static WORD_DECD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oing")],
     values: &[&["decoding"]],
     range: 4..=4,
 };
 
-static WORD_DECC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECC_CHILDREN),
+static WORD_DECC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elerate"),
         dictgen::InsensitiveStr::Ascii("elerated"),
@@ -175280,12 +175280,12 @@ pub static WORD_DECC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DECA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DECA_CHILDREN),
+static WORD_DECA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DECA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DECA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ffinated"),
         dictgen::InsensitiveStr::Ascii("lare"),
@@ -175325,12 +175325,12 @@ pub static WORD_DECA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_DEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEB_CHILDREN),
+static WORD_DEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ateable"),
@@ -175428,12 +175428,12 @@ pub static WORD_DEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_DEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DEA_CHILDREN),
+static WORD_DEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DEA_CHILDREN),
     value: None,
 };
 
-static WORD_DEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DEA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_DEAC_NODE),
@@ -175462,12 +175462,12 @@ static WORD_DEA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DEAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAU_CHILDREN),
+static WORD_DEAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lt"),
         dictgen::InsensitiveStr::Ascii("lts"),
@@ -175477,12 +175477,12 @@ pub static WORD_DEAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_DEAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAT_CHILDREN),
+static WORD_DEAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ail"),
         dictgen::InsensitiveStr::Ascii("ails"),
@@ -175540,23 +175540,23 @@ pub static WORD_DEAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_DEAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAS_CHILDREN),
+static WORD_DEAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sering")],
     values: &[&["deasserting"]],
     range: 6..=6,
 };
 
-static WORD_DEAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAP_CHILDREN),
+static WORD_DEAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("th"),
         dictgen::InsensitiveStr::Ascii("ths"),
@@ -175565,12 +175565,12 @@ pub static WORD_DEAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_DEAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAM_CHILDREN),
+static WORD_DEAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("and"),
         dictgen::InsensitiveStr::Ascii("anding"),
@@ -175634,12 +175634,12 @@ pub static WORD_DEAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_DEAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAL_CHILDREN),
+static WORD_DEAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("erhsip"),
@@ -175673,12 +175673,12 @@ pub static WORD_DEAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_DEAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAK_CHILDREN),
+static WORD_DEAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tivate"),
         dictgen::InsensitiveStr::Ascii("tivated"),
@@ -175687,12 +175687,12 @@ pub static WORD_DEAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_DEAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAI_CHILDREN),
+static WORD_DEAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -175701,23 +175701,23 @@ pub static WORD_DEAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_DEAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAH_CHILDREN),
+static WORD_DEAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tly")],
     values: &[&["deathly"]],
     range: 3..=3,
 };
 
-static WORD_DEAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAF_CHILDREN),
+static WORD_DEAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("eted"),
@@ -175739,23 +175739,23 @@ pub static WORD_DEAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_DEAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAE_CHILDREN),
+static WORD_DEAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mon")],
     values: &[&["daemon"]],
     range: 3..=3,
 };
 
-static WORD_DEAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAD_CHILDREN),
+static WORD_DEAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfit"),
         dictgen::InsensitiveStr::Ascii("lfits"),
@@ -175779,12 +175779,12 @@ pub static WORD_DEAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_DEAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DEAC_CHILDREN),
+static WORD_DEAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DEAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DEAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itivation"),
         dictgen::InsensitiveStr::Ascii("itvated"),
@@ -175822,12 +175822,12 @@ pub static WORD_DEAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_DD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DD_CHILDREN),
+static WORD_DD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elete"),
         dictgen::InsensitiveStr::Ascii("evices"),
@@ -175851,12 +175851,12 @@ pub static WORD_DD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_DC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DC_CHILDREN),
+static WORD_DC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hp"),
         dictgen::InsensitiveStr::Ascii("ok"),
@@ -175888,12 +175888,12 @@ pub static WORD_DC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DB_CHILDREN),
+static WORD_DB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eian"),
@@ -175902,12 +175902,12 @@ pub static WORD_DB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_DA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DA_CHILDREN),
+static WORD_DA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DA_CHILDREN),
     value: None,
 };
 
-static WORD_DA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DAA_NODE),
     Some(&WORD_DAB_NODE),
     Some(&WORD_DAC_NODE),
@@ -175936,45 +175936,45 @@ static WORD_DA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAY_CHILDREN),
+static WORD_DAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bue")],
     values: &[&["debut"]],
     range: 3..=3,
 };
 
-static WORD_DAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAW_CHILDREN),
+static WORD_DAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rves")],
     values: &[&["dwarves"]],
     range: 4..=4,
 };
 
-static WORD_DAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAV_CHILDREN),
+static WORD_DAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("antage")],
     values: &[&["advantage"]],
     range: 6..=6,
 };
 
-static WORD_DAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAU_CHILDREN),
+static WORD_DAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gher"),
         dictgen::InsensitiveStr::Ascii("ghterbord"),
@@ -175996,12 +175996,12 @@ pub static WORD_DAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_DAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_DAT_CHILDREN),
+static WORD_DAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_DAT_CHILDREN),
     value: None,
 };
 
-static WORD_DAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_DAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_DATA_NODE),
     Some(&WORD_DATB_NODE),
     None,
@@ -176030,23 +176030,23 @@ static WORD_DAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_DATY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATY_CHILDREN),
+static WORD_DATY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATY_CHILDREN),
     value: Some(&["data", "date"]),
 };
 
-pub static WORD_DATY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_DATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATS_CHILDREN),
+static WORD_DATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("ets"),
@@ -176055,23 +176055,23 @@ pub static WORD_DATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_DATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATR_CHILDREN),
+static WORD_DATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("abase")],
     values: &[&["database"]],
     range: 5..=5,
 };
 
-static WORD_DATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATE_CHILDREN),
+static WORD_DATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("base"),
@@ -176097,12 +176097,12 @@ pub static WORD_DATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_DATB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATB_CHILDREN),
+static WORD_DATB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ases"),
@@ -176111,12 +176111,12 @@ pub static WORD_DATB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_DATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DATA_CHILDREN),
+static WORD_DATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_DATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baase"),
         dictgen::InsensitiveStr::Ascii("baases"),
@@ -176228,12 +176228,12 @@ pub static WORD_DATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_DAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAS_CHILDREN),
+static WORD_DAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("board"),
         dictgen::InsensitiveStr::Ascii("boards"),
@@ -176271,12 +176271,12 @@ pub static WORD_DAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_DAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAR_CHILDREN),
+static WORD_DAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cula"),
         dictgen::InsensitiveStr::Ascii("denelles"),
@@ -176298,23 +176298,23 @@ pub static WORD_DAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_DAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAP_CHILDREN),
+static WORD_DAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("licating")],
     values: &[&["duplicating"]],
     range: 8..=8,
 };
 
-static WORD_DAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAN_CHILDREN),
+static WORD_DAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceing"),
         dictgen::InsensitiveStr::Ascii("didates"),
@@ -176340,12 +176340,12 @@ pub static WORD_DAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_DAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAM_CHILDREN),
+static WORD_DAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amge"),
         dictgen::InsensitiveStr::Ascii("amged"),
@@ -176387,12 +176387,12 @@ pub static WORD_DAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_DAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAL_CHILDREN),
+static WORD_DAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egate"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -176410,23 +176410,23 @@ pub static WORD_DAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_DAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAK_CHILDREN),
+static WORD_DAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["take"]],
     range: 1..=1,
 };
 
-static WORD_DAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAI_CHILDREN),
+static WORD_DAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logue"),
         dictgen::InsensitiveStr::Ascii("mond"),
@@ -176437,12 +176437,12 @@ pub static WORD_DAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_DAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAH_CHILDREN),
+static WORD_DAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("board"),
         dictgen::InsensitiveStr::Ascii("boards"),
@@ -176452,23 +176452,23 @@ pub static WORD_DAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_DAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAG_CHILDREN),
+static WORD_DAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ners")],
     values: &[&["dangers"]],
     range: 4..=4,
 };
 
-static WORD_DAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAF_CHILDREN),
+static WORD_DAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ault"),
         dictgen::InsensitiveStr::Ascii("aults"),
@@ -176488,12 +176488,12 @@ pub static WORD_DAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_DAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAE_CHILDREN),
+static WORD_DAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -176507,23 +176507,23 @@ pub static WORD_DAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_DAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAD_CHILDREN),
+static WORD_DAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lock")],
     values: &[&["deadlock"]],
     range: 4..=4,
 };
 
-static WORD_DAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAC_CHILDREN),
+static WORD_DAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kery"),
         dictgen::InsensitiveStr::Ascii("laration"),
@@ -176533,12 +176533,12 @@ pub static WORD_DAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_DAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAB_CHILDREN),
+static WORD_DAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_DAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ilitating"),
@@ -176549,23 +176549,23 @@ pub static WORD_DAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_DAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_DAA_CHILDREN),
+static WORD_DAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_DAA_CHILDREN),
     value: Some(&["data"]),
 };
 
-pub static WORD_DAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tsheet")],
     values: &[&["datasheet"]],
     range: 6..=6,
 };
 
-static WORD_C_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_C_CHILDREN),
+static WORD_C_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_C_CHILDREN),
     value: None,
 };
 
-static WORD_C_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_C_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CA_NODE),
     None,
     Some(&WORD_CC_NODE),
@@ -176594,23 +176594,23 @@ static WORD_C_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CZ_NODE),
 ];
 
-static WORD_CZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CZ_CHILDREN),
+static WORD_CZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("echoslavakia")],
     values: &[&["czechoslovakia"]],
     range: 12..=12,
 };
 
-static WORD_CY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CY_CHILDREN),
+static WORD_CY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andie"),
         dictgen::InsensitiveStr::Ascii("cic"),
@@ -176744,34 +176744,34 @@ pub static WORD_CY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_CX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CX_CHILDREN),
+static WORD_CX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CX_CHILDREN),
     value: None,
 };
 
-pub static WORD_CX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("an")],
     values: &[&["cyan"]],
     range: 2..=2,
 };
 
-static WORD_CV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CV_CHILDREN),
+static WORD_CV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ignore")],
     values: &[&["cvsignore"]],
     range: 6..=6,
 };
 
-static WORD_CU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CU_CHILDREN),
+static WORD_CU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CU_CHILDREN),
     value: None,
 };
 
-static WORD_CU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CUA_NODE),
     Some(&WORD_CUB_NODE),
     None,
@@ -176800,12 +176800,12 @@ static WORD_CU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CUZ_NODE),
 ];
 
-static WORD_CUZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUZ_CHILDREN),
+static WORD_CUZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tomizable"),
         dictgen::InsensitiveStr::Ascii("tomization"),
@@ -176831,12 +176831,12 @@ pub static WORD_CUZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=11,
 };
 
-static WORD_CUV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUV_CHILDREN),
+static WORD_CUV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("re"),
@@ -176850,12 +176850,12 @@ pub static WORD_CUV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_CUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUU_CHILDREN),
+static WORD_CUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rently"),
         dictgen::InsensitiveStr::Ascii("rrent"),
@@ -176865,12 +176865,12 @@ pub static WORD_CUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_CUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUT_CHILDREN),
+static WORD_CUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("om"),
@@ -176908,12 +176908,12 @@ pub static WORD_CUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CUS_CHILDREN),
+static WORD_CUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CUS_CHILDREN),
     value: None,
 };
 
-static WORD_CUS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CUS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -176942,12 +176942,12 @@ static WORD_CUS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CUST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CUST_CHILDREN),
+static WORD_CUST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CUST_CHILDREN),
     value: None,
 };
 
-static WORD_CUST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CUST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CUSTA_NODE),
     None,
     Some(&WORD_CUSTC_NODE),
@@ -176976,12 +176976,12 @@ static WORD_CUST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CUSTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTU_CHILDREN),
+static WORD_CUSTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mer"),
@@ -177003,12 +177003,12 @@ pub static WORD_CUSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CUSTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTO_CHILDREN),
+static WORD_CUSTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emr"),
         dictgen::InsensitiveStr::Ascii("emrs"),
@@ -177126,23 +177126,23 @@ pub static WORD_CUSTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CUSTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTM_CHILDREN),
+static WORD_CUSTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["customer"]],
     range: 2..=2,
 };
 
-static WORD_CUSTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTI_CHILDREN),
+static WORD_CUSTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mizable"),
         dictgen::InsensitiveStr::Ascii("mized"),
@@ -177151,12 +177151,12 @@ pub static WORD_CUSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CUSTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTC_CHILDREN),
+static WORD_CUSTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ene"),
         dictgen::InsensitiveStr::Ascii("enes"),
@@ -177165,12 +177165,12 @@ pub static WORD_CUSTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CUSTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSTA_CHILDREN),
+static WORD_CUSTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mizable"),
         dictgen::InsensitiveStr::Ascii("mized"),
@@ -177186,12 +177186,12 @@ pub static WORD_CUSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CUSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSS_CHILDREN),
+static WORD_CUSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("tom"),
@@ -177217,12 +177217,12 @@ pub static WORD_CUSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_CUSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSO_CHILDREN),
+static WORD_CUSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mers"),
@@ -177242,12 +177242,12 @@ pub static WORD_CUSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CUSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSI_CHILDREN),
+static WORD_CUSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ne"),
         dictgen::InsensitiveStr::Ascii("nes"),
@@ -177256,12 +177256,12 @@ pub static WORD_CUSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CUSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUSH_CHILDREN),
+static WORD_CUSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ins"),
@@ -177270,12 +177270,12 @@ pub static WORD_CUSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CUR_CHILDREN),
+static WORD_CUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CUR_CHILDREN),
     value: None,
 };
 
-static WORD_CUR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CUR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CURA_NODE),
     None,
     Some(&WORD_CURC_NODE),
@@ -177304,12 +177304,12 @@ static WORD_CUR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CURV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURV_CHILDREN),
+static WORD_CURV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asious"),
         dictgen::InsensitiveStr::Ascii("atrue"),
@@ -177325,12 +177325,12 @@ pub static WORD_CURV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CURT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURT_CHILDREN),
+static WORD_CURT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esy"),
         dictgen::InsensitiveStr::Ascii("eus"),
@@ -177346,12 +177346,12 @@ pub static WORD_CURT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CURS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURS_CHILDREN),
+static WORD_CURS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ade"),
         dictgen::InsensitiveStr::Ascii("ader"),
@@ -177377,12 +177377,12 @@ pub static WORD_CURS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CURR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CURR_CHILDREN),
+static WORD_CURR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CURR_CHILDREN),
     value: None,
 };
 
-static WORD_CURR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CURR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CURRA_NODE),
     None,
     None,
@@ -177411,12 +177411,12 @@ static WORD_CURR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CURRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRU_CHILDREN),
+static WORD_CURRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -177442,12 +177442,12 @@ pub static WORD_CURRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CURRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRR_CHILDREN),
+static WORD_CURRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ency"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -177457,12 +177457,12 @@ pub static WORD_CURRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CURRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRO_CHILDREN),
+static WORD_CURRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ption"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -177471,12 +177471,12 @@ pub static WORD_CURRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CURRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRN_CHILDREN),
+static WORD_CURRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etly"),
@@ -177487,12 +177487,12 @@ pub static WORD_CURRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CURRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRI_CHILDREN),
+static WORD_CURRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("culem"),
         dictgen::InsensitiveStr::Ascii("culim"),
@@ -177512,12 +177512,12 @@ pub static WORD_CURRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CURRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRE_CHILDREN),
+static WORD_CURRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cnies"),
         dictgen::InsensitiveStr::Ascii("cny"),
@@ -177601,12 +177601,12 @@ pub static WORD_CURRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CURRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURRA_CHILDREN),
+static WORD_CURRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncies"),
         dictgen::InsensitiveStr::Ascii("te"),
@@ -177615,12 +177615,12 @@ pub static WORD_CURRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CURN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURN_CHILDREN),
+static WORD_CURN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("els"),
@@ -177630,12 +177630,12 @@ pub static WORD_CURN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CURI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURI_CHILDREN),
+static WORD_CURI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("culum"),
         dictgen::InsensitiveStr::Ascii("ocity"),
@@ -177665,12 +177665,12 @@ pub static WORD_CURI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CURE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURE_CHILDREN),
+static WORD_CURE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ful"),
         dictgen::InsensitiveStr::Ascii("fully"),
@@ -177704,12 +177704,12 @@ pub static WORD_CURE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CURC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURC_CHILDREN),
+static WORD_CURC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -177741,12 +177741,12 @@ pub static WORD_CURC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CURA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CURA_CHILDREN),
+static WORD_CURA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CURA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CURA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CURA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("geous"),
@@ -177757,12 +177757,12 @@ pub static WORD_CURA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUP_CHILDREN),
+static WORD_CUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baord"),
         dictgen::InsensitiveStr::Ascii("boad"),
@@ -177782,12 +177782,12 @@ pub static WORD_CUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUN_CHILDREN),
+static WORD_CUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("curency"),
         dictgen::InsensitiveStr::Ascii("current"),
@@ -177811,12 +177811,12 @@ pub static WORD_CUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_CUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUM_CHILDREN),
+static WORD_CUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bersomem"),
         dictgen::InsensitiveStr::Ascii("bersone"),
@@ -177854,12 +177854,12 @@ pub static WORD_CUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_CUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUL_CHILDREN),
+static WORD_CUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("iminating"),
@@ -177903,23 +177903,23 @@ pub static WORD_CUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_CUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUI_CHILDREN),
+static WORD_CUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("leoga")],
     values: &[&["cuileog"]],
     range: 5..=5,
 };
 
-static WORD_CUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUE_CHILDREN),
+static WORD_CUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stion"),
         dictgen::InsensitiveStr::Ascii("stionable"),
@@ -177935,12 +177935,12 @@ pub static WORD_CUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_CUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUD_CHILDREN),
+static WORD_CUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dels"),
         dictgen::InsensitiveStr::Ascii("dleys"),
@@ -177949,12 +177949,12 @@ pub static WORD_CUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_CUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUB_CHILDREN),
+static WORD_CUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("burd"),
         dictgen::InsensitiveStr::Ascii("burds"),
@@ -177972,12 +177972,12 @@ pub static WORD_CUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_CUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CUA_CHILDREN),
+static WORD_CUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("casian"),
         dictgen::InsensitiveStr::Ascii("sality"),
@@ -178001,12 +178001,12 @@ pub static WORD_CUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CT_CHILDREN),
+static WORD_CT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eate"),
         dictgen::InsensitiveStr::Ascii("eateing"),
@@ -178050,12 +178050,12 @@ pub static WORD_CT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_CS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CS_CHILDREN),
+static WORD_CS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aes"),
@@ -178066,12 +178066,12 @@ pub static WORD_CS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_CR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CR_CHILDREN),
+static WORD_CR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CR_CHILDREN),
     value: None,
 };
 
-static WORD_CR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CRA_NODE),
     None,
     None,
@@ -178100,12 +178100,12 @@ static WORD_CR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRY_CHILDREN),
+static WORD_CRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pitc"),
         dictgen::InsensitiveStr::Ascii("pric"),
@@ -178159,12 +178159,12 @@ pub static WORD_CRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_CRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRU_CHILDREN),
+static WORD_CRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asder"),
         dictgen::InsensitiveStr::Ascii("ciaal"),
@@ -178240,12 +178240,12 @@ pub static WORD_CRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_CRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRT_CHILDREN),
+static WORD_CRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -178261,12 +178261,12 @@ pub static WORD_CRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_CRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRS_CHILDREN),
+static WORD_CRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ytal"),
         dictgen::InsensitiveStr::Ascii("ytalline"),
@@ -178290,34 +178290,34 @@ pub static WORD_CRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=13,
 };
 
-static WORD_CRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRR_CHILDREN),
+static WORD_CRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("espond")],
     values: &[&["correspond"]],
     range: 6..=6,
 };
 
-static WORD_CRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRP_CHILDREN),
+static WORD_CRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ytic")],
     values: &[&["cryptic"]],
     range: 4..=4,
 };
 
-static WORD_CRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRO_CHILDREN),
+static WORD_CRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atioa"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -178409,12 +178409,12 @@ pub static WORD_CRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_CRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CRI_CHILDREN),
+static WORD_CRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CRI_CHILDREN),
     value: None,
 };
 
-static WORD_CRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CRI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CRIC_NODE),
@@ -178443,12 +178443,12 @@ static WORD_CRI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CRIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CRIT_CHILDREN),
+static WORD_CRIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CRIT_CHILDREN),
     value: None,
 };
 
-static WORD_CRIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CRIT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CRITC_NODE),
@@ -178477,12 +178477,12 @@ static WORD_CRIT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CRITQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRITQ_CHILDREN),
+static WORD_CRITQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRITQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRITQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRITQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ue"),
         dictgen::InsensitiveStr::Ascii("ued"),
@@ -178492,12 +178492,12 @@ pub static WORD_CRITQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_CRITI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRITI_CHILDREN),
+static WORD_CRITI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRITI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRITI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("call"),
@@ -178631,12 +178631,12 @@ pub static WORD_CRITI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CRITE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRITE_CHILDREN),
+static WORD_CRITE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRITE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRITE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("ra"),
@@ -178654,12 +178654,12 @@ pub static WORD_CRITE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_CRITC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRITC_CHILDREN),
+static WORD_CRITC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRITC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRITC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRITC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -178679,12 +178679,12 @@ pub static WORD_CRITC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CRIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIR_CHILDREN),
+static WORD_CRIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ical"),
         dictgen::InsensitiveStr::Ascii("ically"),
@@ -178694,12 +178694,12 @@ pub static WORD_CRIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CRIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIP_CHILDREN),
+static WORD_CRIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -178708,12 +178708,12 @@ pub static WORD_CRIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CRIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIN_CHILDREN),
+static WORD_CRIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gely"),
         dictgen::InsensitiveStr::Ascii("gery"),
@@ -178743,12 +178743,12 @@ pub static WORD_CRIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_CRIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIM_CHILDREN),
+static WORD_CRIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anally"),
         dictgen::InsensitiveStr::Ascii("inalty"),
@@ -178764,23 +178764,23 @@ pub static WORD_CRIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CRIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIG_CHILDREN),
+static WORD_CRIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("neworthy")],
     values: &[&["cringeworthy"]],
     range: 8..=8,
 };
 
-static WORD_CRIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRIC_CHILDREN),
+static WORD_CRIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ital"),
         dictgen::InsensitiveStr::Ascii("itally"),
@@ -178808,23 +178808,23 @@ pub static WORD_CRIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CRH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRH_CHILDREN),
+static WORD_CRH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("istmas")],
     values: &[&["christmas"]],
     range: 6..=6,
 };
 
-static WORD_CRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CRE_CHILDREN),
+static WORD_CRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CRE_CHILDREN),
     value: None,
 };
 
-static WORD_CRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CREA_NODE),
     None,
     None,
@@ -178853,34 +178853,34 @@ static WORD_CRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CREW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREW_CHILDREN),
+static WORD_CREW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREW_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sant")],
     values: &[&["croissant"]],
     range: 4..=4,
 };
 
-static WORD_CREU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREU_CHILDREN),
+static WORD_CREU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lty")],
     values: &[&["cruelty"]],
     range: 3..=3,
 };
 
-static WORD_CRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRET_CHILDREN),
+static WORD_CRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRET_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -178918,12 +178918,12 @@ pub static WORD_CRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRES_CHILDREN),
+static WORD_CRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -178933,23 +178933,23 @@ pub static WORD_CRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREN_CHILDREN),
+static WORD_CREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ditals")],
     values: &[&["credentials"]],
     range: 6..=6,
 };
 
-static WORD_CREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREE_CHILDREN),
+static WORD_CREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ates"),
@@ -178971,12 +178971,12 @@ pub static WORD_CREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CRED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRED_CHILDREN),
+static WORD_CRED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("encials"),
@@ -179024,12 +179024,12 @@ pub static WORD_CRED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CREA_CHILDREN),
+static WORD_CREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("cionism"),
@@ -179139,23 +179139,23 @@ pub static WORD_CREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CRD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRD_CHILDREN),
+static WORD_CRD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("it")],
     values: &[&["credit"]],
     range: 2..=2,
 };
 
-static WORD_CRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CRA_CHILDREN),
+static WORD_CRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bine"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -179255,12 +179255,12 @@ pub static WORD_CRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_CP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CP_CHILDREN),
+static WORD_CP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acities"),
         dictgen::InsensitiveStr::Ascii("acity"),
@@ -179290,12 +179290,12 @@ pub static WORD_CP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_CO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CO_CHILDREN),
+static WORD_CO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CO_CHILDREN),
     value: None,
 };
 
-static WORD_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COA_NODE),
     Some(&WORD_COB_NODE),
     Some(&WORD_COC_NODE),
@@ -179324,12 +179324,12 @@ static WORD_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COY_CHILDREN),
+static WORD_COY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COY_CHILDREN),
     value: None,
 };
 
-pub static WORD_COY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("otees"),
         dictgen::InsensitiveStr::Ascii("p"),
@@ -179355,12 +179355,12 @@ pub static WORD_COY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_COV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COV_CHILDREN),
+static WORD_COV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COV_CHILDREN),
     value: None,
 };
 
-pub static WORD_COV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anent"),
         dictgen::InsensitiveStr::Ascii("arage"),
@@ -179448,12 +179448,12 @@ pub static WORD_COV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_COU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COU_CHILDREN),
+static WORD_COU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COU_CHILDREN),
     value: None,
 };
 
-static WORD_COU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_COUC_NODE),
@@ -179482,23 +179482,23 @@ static WORD_COU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUU_CHILDREN),
+static WORD_COUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ld")],
     values: &[&["could"]],
     range: 2..=2,
 };
 
-static WORD_COUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUT_CHILDREN),
+static WORD_COUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -179552,12 +179552,12 @@ pub static WORD_COUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=13,
 };
 
-static WORD_COUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUS_CHILDREN),
+static WORD_COUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -179581,12 +179581,12 @@ pub static WORD_COUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_COUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUR_CHILDREN),
+static WORD_COUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -179628,23 +179628,23 @@ pub static WORD_COUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_COUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUP_CHILDREN),
+static WORD_COUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("el")],
     values: &[&["couple"]],
     range: 2..=2,
 };
 
-static WORD_COUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COUN_CHILDREN),
+static WORD_COUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COUN_CHILDREN),
     value: None,
 };
 
-static WORD_COUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COUN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_COUNC_NODE),
@@ -179673,12 +179673,12 @@ static WORD_COUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COUNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNT_CHILDREN),
+static WORD_COUNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainer"),
@@ -179808,12 +179808,12 @@ pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_COUNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNS_CHILDREN),
+static WORD_COUNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eil"),
         dictgen::InsensitiveStr::Ascii("elers"),
@@ -179849,12 +179849,12 @@ pub static WORD_COUNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COUNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNR_CHILDREN),
+static WORD_COUNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ies"),
         dictgen::InsensitiveStr::Ascii("ty"),
@@ -179864,12 +179864,12 @@ pub static WORD_COUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_COUNP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNP_CHILDREN),
+static WORD_COUNP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ound"),
         dictgen::InsensitiveStr::Ascii("ounds"),
@@ -179878,34 +179878,34 @@ pub static WORD_COUNP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_COUNL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNL_CHILDREN),
+static WORD_COUNL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["could"]],
     range: 1..=1,
 };
 
-static WORD_COUNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNI_CHILDREN),
+static WORD_COUNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ng")],
     values: &[&["counting"]],
     range: 2..=2,
 };
 
-static WORD_COUND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUND_CHILDREN),
+static WORD_COUND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUND_CHILDREN),
     value: Some(&["could", "count", "found"]),
 };
 
-pub static WORD_COUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -179916,12 +179916,12 @@ pub static WORD_COUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_COUNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUNC_CHILDREN),
+static WORD_COUNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUNC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUNC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -179961,12 +179961,12 @@ pub static WORD_COUNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_COUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUM_CHILDREN),
+static WORD_COUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("munities"),
         dictgen::InsensitiveStr::Ascii("munity"),
@@ -179984,12 +179984,12 @@ pub static WORD_COUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_COUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUL_CHILDREN),
+static WORD_COUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUL_CHILDREN),
     value: Some(&["could"]),
 };
 
-pub static WORD_COUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dnot"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -180021,34 +180021,34 @@ pub static WORD_COUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_COUK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUK_CHILDREN),
+static WORD_COUK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUK_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["could"]],
     range: 1..=1,
 };
 
-static WORD_COUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUG_CHILDREN),
+static WORD_COUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ht")],
     values: &[&["caught", "cough", "fought"]],
     range: 2..=2,
 };
 
-static WORD_COUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUD_CHILDREN),
+static WORD_COUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUD_CHILDREN),
     value: Some(&["could"]),
 };
 
-pub static WORD_COUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lnt"),
@@ -180057,23 +180057,23 @@ pub static WORD_COUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_COUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COUC_CHILDREN),
+static WORD_COUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("il")],
     values: &[&["council"]],
     range: 2..=2,
 };
 
-static WORD_COT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COT_CHILDREN),
+static WORD_COT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("ain"),
@@ -180135,12 +180135,12 @@ pub static WORD_COT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_COS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COS_CHILDREN),
+static WORD_COS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -180250,12 +180250,12 @@ pub static WORD_COS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_COR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COR_CHILDREN),
+static WORD_COR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COR_CHILDREN),
     value: None,
 };
 
-static WORD_COR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CORA_NODE),
     None,
     Some(&WORD_CORC_NODE),
@@ -180284,34 +180284,34 @@ static WORD_COR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CORW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORW_CHILDREN),
+static WORD_CORW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORW_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bar")],
     values: &[&["crowbar"]],
     range: 3..=3,
 };
 
-static WORD_CORV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORV_CHILDREN),
+static WORD_CORV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ering")],
     values: &[&["covering"]],
     range: 5..=5,
 };
 
-static WORD_CORU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORU_CHILDREN),
+static WORD_CORU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ching"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -180335,12 +180335,12 @@ pub static WORD_CORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CORS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORS_CHILDREN),
+static WORD_CORS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ari"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -180373,12 +180373,12 @@ pub static WORD_CORS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CORR_CHILDREN),
+static WORD_CORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CORR_CHILDREN),
     value: None,
 };
 
-static WORD_CORR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CORR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CORRA_NODE),
     None,
     Some(&WORD_CORRC_NODE),
@@ -180407,12 +180407,12 @@ static WORD_CORR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CORRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRU_CHILDREN),
+static WORD_CORRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lates"),
         dictgen::InsensitiveStr::Ascii("pcion"),
@@ -180438,12 +180438,12 @@ pub static WORD_CORRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CORRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRS_CHILDREN),
+static WORD_CORRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eponding"),
         dictgen::InsensitiveStr::Ascii("pond"),
@@ -180465,12 +180465,12 @@ pub static WORD_CORRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CORRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRR_CHILDREN),
+static WORD_CORRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -180504,12 +180504,12 @@ pub static WORD_CORRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CORRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRP_CHILDREN),
+static WORD_CORRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uted"),
         dictgen::InsensitiveStr::Ascii("ution"),
@@ -180518,12 +180518,12 @@ pub static WORD_CORRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_CORRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRO_CHILDREN),
+static WORD_CORRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lated"),
         dictgen::InsensitiveStr::Ascii("lates"),
@@ -180549,12 +180549,12 @@ pub static WORD_CORRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_CORRL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRL_CHILDREN),
+static WORD_CORRL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eation"),
         dictgen::InsensitiveStr::Ascii("eations"),
@@ -180563,12 +180563,12 @@ pub static WORD_CORRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_CORRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRI_CHILDREN),
+static WORD_CORRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("door"),
         dictgen::InsensitiveStr::Ascii("doors"),
@@ -180604,12 +180604,12 @@ pub static WORD_CORRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_CORRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CORRE_CHILDREN),
+static WORD_CORRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CORRE_CHILDREN),
     value: None,
 };
 
-static WORD_CORRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CORRE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CORREA_NODE),
     None,
     Some(&WORD_CORREC_NODE),
@@ -180638,12 +180638,12 @@ static WORD_CORRE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CORRET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRET_CHILDREN),
+static WORD_CORRET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRET_CHILDREN),
     value: Some(&["correct"]),
 };
 
-pub static WORD_CORRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -180653,12 +180653,12 @@ pub static WORD_CORRET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_CORRES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRES_CHILDREN),
+static WORD_CORRES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ond"),
         dictgen::InsensitiveStr::Ascii("onded"),
@@ -180782,12 +180782,12 @@ pub static WORD_CORRES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_CORREP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREP_CHILDREN),
+static WORD_CORREP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ond"),
         dictgen::InsensitiveStr::Ascii("onding"),
@@ -180813,23 +180813,23 @@ pub static WORD_CORREP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_CORREO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREO_CHILDREN),
+static WORD_CORREO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("graph")],
     values: &[&["choreograph"]],
     range: 5..=5,
 };
 
-static WORD_CORREN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREN_CHILDREN),
+static WORD_CORREN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("spond"),
         dictgen::InsensitiveStr::Ascii("sponded"),
@@ -180859,12 +180859,12 @@ pub static WORD_CORREN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_CORREL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREL_CHILDREN),
+static WORD_CORREL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("asion"),
@@ -180896,12 +180896,12 @@ pub static WORD_CORREL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_CORREK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREK_CHILDREN),
+static WORD_CORREK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ting"),
         dictgen::InsensitiveStr::Ascii("tions"),
@@ -180911,23 +180911,23 @@ pub static WORD_CORREK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_CORREG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREG_CHILDREN),
+static WORD_CORREG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ated")],
     values: &[&["correlated"]],
     range: 4..=4,
 };
 
-static WORD_CORREE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREE_CHILDREN),
+static WORD_CORREE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("ctly"),
@@ -180953,23 +180953,23 @@ pub static WORD_CORREE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_CORRED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRED_CHILDREN),
+static WORD_CORRED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ct")],
     values: &[&["correct"]],
     range: 2..=2,
 };
 
-static WORD_CORREC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREC_CHILDREN),
+static WORD_CORREC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cion"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -181047,23 +181047,23 @@ pub static WORD_CORREC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CORREA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORREA_CHILDREN),
+static WORD_CORREA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORREA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORREA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORREA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lation")],
     values: &[&["correlation"]],
     range: 6..=6,
 };
 
-static WORD_CORRD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRD_CHILDREN),
+static WORD_CORRD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inate"),
         dictgen::InsensitiveStr::Ascii("inated"),
@@ -181087,12 +181087,12 @@ pub static WORD_CORRD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CORRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRC_CHILDREN),
+static WORD_CORRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -181101,12 +181101,12 @@ pub static WORD_CORRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CORRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORRA_CHILDREN),
+static WORD_CORRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lated"),
         dictgen::InsensitiveStr::Ascii("lates"),
@@ -181116,12 +181116,12 @@ pub static WORD_CORRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CORP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORP_CHILDREN),
+static WORD_CORP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("aration"),
@@ -181167,12 +181167,12 @@ pub static WORD_CORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_CORO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORO_CHILDREN),
+static WORD_CORO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llla"),
         dictgen::InsensitiveStr::Ascii("lloa"),
@@ -181208,12 +181208,12 @@ pub static WORD_CORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_CORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORN_CHILDREN),
+static WORD_CORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ders"),
         dictgen::InsensitiveStr::Ascii("el"),
@@ -181233,12 +181233,12 @@ pub static WORD_CORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORI_CHILDREN),
+static WORD_CORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dal"),
         dictgen::InsensitiveStr::Ascii("nthains"),
@@ -181268,34 +181268,34 @@ pub static WORD_CORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORG_CHILDREN),
+static WORD_CORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nito")],
     values: &[&["cognito"]],
     range: 4..=4,
 };
 
-static WORD_CORF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORF_CHILDREN),
+static WORD_CORF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("irms")],
     values: &[&["confirms"]],
     range: 4..=4,
 };
 
-static WORD_CORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORE_CHILDREN),
+static WORD_CORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cct"),
         dictgen::InsensitiveStr::Ascii("cctly"),
@@ -181355,12 +181355,12 @@ pub static WORD_CORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORD_CHILDREN),
+static WORD_CORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iante"),
         dictgen::InsensitiveStr::Ascii("inates"),
@@ -181378,23 +181378,23 @@ pub static WORD_CORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CORC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORC_CHILDREN),
+static WORD_CORC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("odile")],
     values: &[&["crocodile"]],
     range: 5..=5,
 };
 
-static WORD_CORA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CORA_CHILDREN),
+static WORD_CORA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CORA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CORA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("lina"),
@@ -181405,12 +181405,12 @@ pub static WORD_CORA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_COP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COP_CHILDREN),
+static WORD_COP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COP_CHILDREN),
     value: None,
 };
 
-static WORD_COP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COPA_NODE),
     None,
     None,
@@ -181439,12 +181439,12 @@ static WORD_COP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPY_CHILDREN),
+static WORD_COPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPY_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eight"),
@@ -181506,23 +181506,23 @@ pub static WORD_COPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_COPV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPV_CHILDREN),
+static WORD_COPV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPV_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["cover"]],
     range: 2..=2,
 };
 
-static WORD_COPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPU_CHILDREN),
+static WORD_COPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ling"),
         dictgen::InsensitiveStr::Ascii("right"),
@@ -181546,23 +181546,23 @@ pub static WORD_COPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPS_CHILDREN),
+static WORD_COPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("truction")],
     values: &[&["construction"]],
     range: 8..=8,
 };
 
-static WORD_COPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPR_CHILDREN),
+static WORD_COPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ight"),
         dictgen::InsensitiveStr::Ascii("ighted"),
@@ -181600,12 +181600,12 @@ pub static WORD_COPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_COPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPP_CHILDREN),
+static WORD_COPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ermines"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -181615,12 +181615,12 @@ pub static WORD_COPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_COPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPO_CHILDREN),
+static WORD_COPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nent"),
         dictgen::InsensitiveStr::Ascii("nents"),
@@ -181636,23 +181636,23 @@ pub static WORD_COPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_COPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPN_CHILDREN),
+static WORD_COPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("troller")],
     values: &[&["controller"]],
     range: 7..=7,
 };
 
-static WORD_COPM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPM_CHILDREN),
+static WORD_COPM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etitors"),
         dictgen::InsensitiveStr::Ascii("ilation"),
@@ -181670,12 +181670,12 @@ pub static WORD_COPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_COPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPL_CHILDREN),
+static WORD_COPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ete"),
@@ -181693,12 +181693,12 @@ pub static WORD_COPL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_COPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPI_CHILDREN),
+static WORD_COPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ese"),
@@ -181714,12 +181714,12 @@ pub static WORD_COPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_COPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPE_CHILDREN),
+static WORD_COPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hnagen"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -181759,23 +181759,23 @@ pub static WORD_COPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_COPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COPA_CHILDREN),
+static WORD_COPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ny")],
     values: &[&["company"]],
     range: 2..=2,
 };
 
-static WORD_COO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COO_CHILDREN),
+static WORD_COO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COO_CHILDREN),
     value: None,
 };
 
-static WORD_COO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -181804,12 +181804,12 @@ static WORD_COO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOT_CHILDREN),
+static WORD_COOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dinate"),
         dictgen::InsensitiveStr::Ascii("dinated"),
@@ -181827,12 +181827,12 @@ pub static WORD_COOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_COOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COOR_CHILDREN),
+static WORD_COOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COOR_CHILDREN),
     value: None,
 };
 
-static WORD_COOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -181861,12 +181861,12 @@ static WORD_COOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COORP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORP_CHILDREN),
+static WORD_COORP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eration"),
         dictgen::InsensitiveStr::Ascii("erations"),
@@ -181878,23 +181878,23 @@ pub static WORD_COORP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_COORN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORN_CHILDREN),
+static WORD_COORN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ates")],
     values: &[&["coordinates"]],
     range: 4..=4,
 };
 
-static WORD_COORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORI_CHILDREN),
+static WORD_COORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("date"),
         dictgen::InsensitiveStr::Ascii("dated"),
@@ -181928,12 +181928,12 @@ pub static WORD_COORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_COORE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORE_CHILDREN),
+static WORD_COORE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("spond"),
@@ -181955,12 +181955,12 @@ pub static WORD_COORE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COORD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COORD_CHILDREN),
+static WORD_COORD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COORD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COORD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anate"),
         dictgen::InsensitiveStr::Ascii("anates"),
@@ -182076,12 +182076,12 @@ pub static WORD_COORD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_COOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOP_CHILDREN),
+static WORD_COOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aretive"),
         dictgen::InsensitiveStr::Ascii("earte"),
@@ -182107,12 +182107,12 @@ pub static WORD_COOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_COOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOO_CHILDREN),
+static WORD_COOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rdinate"),
         dictgen::InsensitiveStr::Ascii("rdinates"),
@@ -182121,12 +182121,12 @@ pub static WORD_COOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_COON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COON_CHILDREN),
+static WORD_COON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COON_CHILDREN),
     value: None,
 };
 
-pub static WORD_COON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nection"),
         dictgen::InsensitiveStr::Ascii("stantly"),
@@ -182142,12 +182142,12 @@ pub static WORD_COON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_COOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOM_CHILDREN),
+static WORD_COOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("and"),
         dictgen::InsensitiveStr::Ascii("mand"),
@@ -182158,12 +182158,12 @@ pub static WORD_COOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_COOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOL_CHILDREN),
+static WORD_COOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dows"),
         dictgen::InsensitiveStr::Ascii("dwons"),
@@ -182181,34 +182181,34 @@ pub static WORD_COOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_COOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOK_CHILDREN),
+static WORD_COOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oo")],
     values: &[&["cuckoo"]],
     range: 2..=2,
 };
 
-static WORD_COOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOG_CHILDREN),
+static WORD_COOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["cougar"]],
     range: 2..=2,
 };
 
-static WORD_COOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOE_CHILDREN),
+static WORD_COOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fficient"),
         dictgen::InsensitiveStr::Ascii("fficients"),
@@ -182217,12 +182217,12 @@ pub static WORD_COOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_COOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COOD_CHILDREN),
+static WORD_COOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inate"),
         dictgen::InsensitiveStr::Ascii("inates"),
@@ -182238,12 +182238,12 @@ pub static WORD_COOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CON_CHILDREN),
+static WORD_CON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CON_CHILDREN),
     value: None,
 };
 
-static WORD_CON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CON_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONA_NODE),
     Some(&WORD_CONB_NODE),
     Some(&WORD_CONC_NODE),
@@ -182272,23 +182272,23 @@ static WORD_CON_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONY_CHILDREN),
+static WORD_CONY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ak")],
     values: &[&["cognac"]],
     range: 2..=2,
 };
 
-static WORD_CONV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONV_CHILDREN),
+static WORD_CONV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONV_CHILDREN),
     value: None,
 };
 
-static WORD_CONV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONVA_NODE),
     None,
     Some(&WORD_CONVC_NODE),
@@ -182317,12 +182317,12 @@ static WORD_CONV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONVU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVU_CHILDREN),
+static WORD_CONVU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lated"),
         dictgen::InsensitiveStr::Ascii("luted"),
@@ -182331,12 +182331,12 @@ pub static WORD_CONVU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_CONVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVS_CHILDREN),
+static WORD_CONVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eration"),
         dictgen::InsensitiveStr::Ascii("erion"),
@@ -182345,12 +182345,12 @@ pub static WORD_CONVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CONVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVR_CHILDREN),
+static WORD_CONVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ets"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -182359,12 +182359,12 @@ pub static WORD_CONVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CONVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVO_CHILDREN),
+static WORD_CONVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("luded"),
         dictgen::InsensitiveStr::Ascii("rsation"),
@@ -182390,23 +182390,23 @@ pub static WORD_CONVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CONVN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVN_CHILDREN),
+static WORD_CONVN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etions")],
     values: &[&["conventions"]],
     range: 6..=6,
 };
 
-static WORD_CONVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVI_CHILDREN),
+static WORD_CONVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccion"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -182524,12 +182524,12 @@ pub static WORD_CONVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_CONVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONVE_CHILDREN),
+static WORD_CONVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONVE_CHILDREN),
     value: None,
 };
 
-static WORD_CONVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONVE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -182558,12 +182558,12 @@ static WORD_CONVE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONVEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEY_CHILDREN),
+static WORD_CONVEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -182572,23 +182572,23 @@ pub static WORD_CONVEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONVEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEX_CHILDREN),
+static WORD_CONVEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["convex", "convexes"]],
     range: 1..=1,
 };
 
-static WORD_CONVET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVET_CHILDREN),
+static WORD_CONVET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVET_CHILDREN),
     value: Some(&["convert"]),
 };
 
-pub static WORD_CONVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -182610,12 +182610,12 @@ pub static WORD_CONVET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONVES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVES_CHILDREN),
+static WORD_CONVES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -182631,12 +182631,12 @@ pub static WORD_CONVES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_CONVER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONVER_CHILDREN),
+static WORD_CONVER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONVER_CHILDREN),
     value: Some(&["convert"]),
 };
 
-static WORD_CONVER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONVER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONVERA_NODE),
     None,
     None,
@@ -182665,34 +182665,34 @@ static WORD_CONVER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONVERZ_NODE),
 ];
 
-static WORD_CONVERZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERZ_CHILDREN),
+static WORD_CONVERZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["conservation"]],
     range: 5..=5,
 };
 
-static WORD_CONVERY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERY_CHILDREN),
+static WORD_CONVERY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERY_CHILDREN),
     value: Some(&["convert"]),
 };
 
-pub static WORD_CONVERY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["converting"]],
     range: 3..=3,
 };
 
-static WORD_CONVERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERV_CHILDREN),
+static WORD_CONVERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -182722,12 +182722,12 @@ pub static WORD_CONVERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONVERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERT_CHILDREN),
+static WORD_CONVERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ables"),
@@ -182773,12 +182773,12 @@ pub static WORD_CONVERT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONVERS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERS_CHILDREN),
+static WORD_CONVERS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERS_CHILDREN),
     value: Some(&["converts", "converse", "convert"]),
 };
 
-pub static WORD_CONVERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("acional"),
@@ -182860,23 +182860,23 @@ pub static WORD_CONVERS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=9,
 };
 
-static WORD_CONVERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERN_CHILDREN),
+static WORD_CONVERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["converting"]],
     range: 3..=3,
 };
 
-static WORD_CONVERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERI_CHILDREN),
+static WORD_CONVERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ng"),
         dictgen::InsensitiveStr::Ascii("on"),
@@ -182894,12 +182894,12 @@ pub static WORD_CONVERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_CONVERG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERG_CHILDREN),
+static WORD_CONVERG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ens"),
@@ -182908,12 +182908,12 @@ pub static WORD_CONVERG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_CONVERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERE_CHILDREN),
+static WORD_CONVERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("sly"),
@@ -182923,23 +182923,23 @@ pub static WORD_CONVERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_CONVERD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERD_CHILDREN),
+static WORD_CONVERD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["conservation"]],
     range: 5..=5,
 };
 
-static WORD_CONVERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVERA_CHILDREN),
+static WORD_CONVERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("stion"),
@@ -182955,12 +182955,12 @@ pub static WORD_CONVERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_CONVEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEN_CHILDREN),
+static WORD_CONVEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("cen"),
@@ -183030,23 +183030,23 @@ pub static WORD_CONVEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_CONVEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEL_CHILDREN),
+static WORD_CONVEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uted")],
     values: &[&["convoluted"]],
     range: 4..=4,
 };
 
-static WORD_CONVEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVEI_CHILDREN),
+static WORD_CONVEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("nce"),
@@ -183070,34 +183070,34 @@ pub static WORD_CONVEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_CONVED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVED_CHILDREN),
+static WORD_CONVED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sion")],
     values: &[&["conversion"]],
     range: 4..=4,
 };
 
-static WORD_CONVC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVC_CHILDREN),
+static WORD_CONVC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ition")],
     values: &[&["convictions"]],
     range: 5..=5,
 };
 
-static WORD_CONVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONVA_CHILDREN),
+static WORD_CONVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("less"),
         dictgen::InsensitiveStr::Ascii("luted"),
@@ -183117,12 +183117,12 @@ pub static WORD_CONVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CONU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONU_CHILDREN),
+static WORD_CONU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntry"),
         dictgen::InsensitiveStr::Ascii("smer"),
@@ -183131,12 +183131,12 @@ pub static WORD_CONU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_CONT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONT_CHILDREN),
+static WORD_CONT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONT_CHILDREN),
     value: None,
 };
 
-static WORD_CONT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTA_NODE),
     None,
     Some(&WORD_CONTC_NODE),
@@ -183165,23 +183165,23 @@ static WORD_CONT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTZ_NODE),
 ];
 
-static WORD_CONTZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTZ_CHILDREN),
+static WORD_CONTZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ains")],
     values: &[&["contains"]],
     range: 4..=4,
 };
 
-static WORD_CONTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTU_CHILDREN),
+static WORD_CONTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ine"),
         dictgen::InsensitiveStr::Ascii("ining"),
@@ -183197,12 +183197,12 @@ pub static WORD_CONTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CONTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTT_CHILDREN),
+static WORD_CONTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ribute"),
         dictgen::InsensitiveStr::Ascii("ributed"),
@@ -183224,12 +183224,12 @@ pub static WORD_CONTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_CONTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTS_CHILDREN),
+static WORD_CONTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ruction"),
         dictgen::InsensitiveStr::Ascii("ructor"),
@@ -183263,12 +183263,12 @@ pub static WORD_CONTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTR_CHILDREN),
+static WORD_CONTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTR_CHILDREN),
     value: None,
 };
 
-static WORD_CONTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTRA_NODE),
     Some(&WORD_CONTRB_NODE),
     Some(&WORD_CONTRC_NODE),
@@ -183297,23 +183297,23 @@ static WORD_CONTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRY_CHILDREN),
+static WORD_CONTRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRY_CHILDREN),
     value: Some(&["country"]),
 };
 
-pub static WORD_CONTRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ie")],
     values: &[&["countryie"]],
     range: 2..=2,
 };
 
-static WORD_CONTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRU_CHILDREN),
+static WORD_CONTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bite"),
         dictgen::InsensitiveStr::Ascii("bute"),
@@ -183343,23 +183343,23 @@ pub static WORD_CONTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CONTRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRT_CHILDREN),
+static WORD_CONTRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oller")],
     values: &[&["controller"]],
     range: 5..=5,
 };
 
-static WORD_CONTRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRS_CHILDREN),
+static WORD_CONTRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -183375,12 +183375,12 @@ pub static WORD_CONTRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONTRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRR_CHILDREN),
+static WORD_CONTRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ol"),
         dictgen::InsensitiveStr::Ascii("ols"),
@@ -183389,12 +183389,12 @@ pub static WORD_CONTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=3,
 };
 
-static WORD_CONTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRO_CHILDREN),
+static WORD_CONTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRO_CHILDREN),
     value: Some(&["control"]),
 };
 
-pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ception"),
         dictgen::InsensitiveStr::Ascii("ceptives"),
@@ -183492,23 +183492,23 @@ pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CONTRL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRL_CHILDREN),
+static WORD_CONTRL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRL_CHILDREN),
     value: Some(&["control"]),
 };
 
-pub static WORD_CONTRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ler")],
     values: &[&["controller"]],
     range: 3..=3,
 };
 
-static WORD_CONTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRI_CHILDREN),
+static WORD_CONTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bte"),
         dictgen::InsensitiveStr::Ascii("bted"),
@@ -183620,12 +183620,12 @@ pub static WORD_CONTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CONTRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRE_CHILDREN),
+static WORD_CONTRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ception"),
         dictgen::InsensitiveStr::Ascii("dict"),
@@ -183645,34 +183645,34 @@ pub static WORD_CONTRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CONTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRC_CHILDREN),
+static WORD_CONTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["contract"]],
     range: 1..=1,
 };
 
-static WORD_CONTRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRB_CHILDREN),
+static WORD_CONTRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ution")],
     values: &[&["contribution"]],
     range: 5..=5,
 };
 
-static WORD_CONTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTRA_CHILDREN),
+static WORD_CONTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bution"),
         dictgen::InsensitiveStr::Ascii("ccion"),
@@ -183790,12 +183790,12 @@ pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CONTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTO_CHILDREN),
+static WORD_CONTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("ler"),
@@ -183829,12 +183829,12 @@ pub static WORD_CONTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CONTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTN_CHILDREN),
+static WORD_CONTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("iue"),
@@ -183852,12 +183852,12 @@ pub static WORD_CONTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CONTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTI_CHILDREN),
+static WORD_CONTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTI_CHILDREN),
     value: None,
 };
 
-static WORD_CONTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTIA_NODE),
     Some(&WORD_CONTIB_NODE),
     None,
@@ -183886,12 +183886,12 @@ static WORD_CONTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIU_CHILDREN),
+static WORD_CONTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -183923,12 +183923,12 @@ pub static WORD_CONTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_CONTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIT_CHILDREN),
+static WORD_CONTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -183938,12 +183938,12 @@ pub static WORD_CONTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_CONTIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIR_CHILDREN),
+static WORD_CONTIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("buted"),
         dictgen::InsensitiveStr::Ascii("bution"),
@@ -183953,12 +183953,12 @@ pub static WORD_CONTIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_CONTIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIO_CHILDREN),
+static WORD_CONTIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("us"),
         dictgen::InsensitiveStr::Ascii("usly"),
@@ -183967,12 +183967,12 @@ pub static WORD_CONTIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTIN_CHILDREN),
+static WORD_CONTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTIN_CHILDREN),
     value: None,
 };
 
-static WORD_CONTIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTIN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONTINA_NODE),
     None,
     None,
@@ -184001,12 +184001,12 @@ static WORD_CONTIN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTINU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINU_CHILDREN),
+static WORD_CONTINU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("aly"),
@@ -184106,34 +184106,34 @@ pub static WORD_CONTINU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONTINT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINT_CHILDREN),
+static WORD_CONTINT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ent")],
     values: &[&["contingent"]],
     range: 3..=3,
 };
 
-static WORD_CONTINS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINS_CHILDREN),
+static WORD_CONTINS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINS_CHILDREN),
     value: Some(&["contains"]),
 };
 
-pub static WORD_CONTINS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_CONTINO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINO_CHILDREN),
+static WORD_CONTINO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ue"),
         dictgen::InsensitiveStr::Ascii("uesly"),
@@ -184153,12 +184153,12 @@ pub static WORD_CONTINO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=5,
 };
 
-static WORD_CONTINI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINI_CHILDREN),
+static WORD_CONTINI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -184176,12 +184176,12 @@ pub static WORD_CONTINI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=5,
 };
 
-static WORD_CONTING_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTING_CHILDREN),
+static WORD_CONTING_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTING_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTING_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancy"),
         dictgen::InsensitiveStr::Ascii("ecy"),
@@ -184205,12 +184205,12 @@ pub static WORD_CONTING_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_CONTINE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINE_CHILDREN),
+static WORD_CONTINE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINE_CHILDREN),
     value: Some(&["continue", "contain"]),
 };
 
-pub static WORD_CONTINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("nal"),
@@ -184246,12 +184246,12 @@ pub static WORD_CONTINE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_CONTINA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTINA_CHILDREN),
+static WORD_CONTINA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTINA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTINA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -184267,12 +184267,12 @@ pub static WORD_CONTINA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_CONTIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIM_CHILDREN),
+static WORD_CONTIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("plate"),
         dictgen::InsensitiveStr::Ascii("plating"),
@@ -184281,12 +184281,12 @@ pub static WORD_CONTIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=7,
 };
 
-static WORD_CONTIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIG_CHILDREN),
+static WORD_CONTIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ency"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -184320,23 +184320,23 @@ pub static WORD_CONTIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_CONTIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIE_CHILDREN),
+static WORD_CONTIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ntous")],
     values: &[&["contentious"]],
     range: 5..=5,
 };
 
-static WORD_CONTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIB_CHILDREN),
+static WORD_CONTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ute"),
         dictgen::InsensitiveStr::Ascii("uted"),
@@ -184358,12 +184358,12 @@ pub static WORD_CONTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_CONTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTIA_CHILDREN),
+static WORD_CONTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ins"),
@@ -184389,23 +184389,23 @@ pub static WORD_CONTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_CONTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTF_CHILDREN),
+static WORD_CONTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ibs")],
     values: &[&["contribs"]],
     range: 3..=3,
 };
 
-static WORD_CONTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTE_CHILDREN),
+static WORD_CONTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTE_CHILDREN),
     value: None,
 };
 
-static WORD_CONTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONTEC_NODE),
@@ -184434,12 +184434,12 @@ static WORD_CONTE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEX_CHILDREN),
+static WORD_CONTEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEX_CHILDREN),
     value: Some(&["context"]),
 };
 
-pub static WORD_CONTEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ta"),
         dictgen::InsensitiveStr::Ascii("tes"),
@@ -184463,12 +184463,12 @@ pub static WORD_CONTEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONTET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTET_CHILDREN),
+static WORD_CONTET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTET_CHILDREN),
     value: Some(&["contest", "content", "context"]),
 };
 
-pub static WORD_CONTET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -184478,12 +184478,12 @@ pub static WORD_CONTET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONTES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTES_CHILDREN),
+static WORD_CONTES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("tais"),
@@ -184513,12 +184513,12 @@ pub static WORD_CONTES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_CONTER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTER_CHILDREN),
+static WORD_CONTER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTER_CHILDREN),
     value: Some(&["conteur", "counter"]),
 };
 
-pub static WORD_CONTER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mporaneous"),
         dictgen::InsensitiveStr::Ascii("part"),
@@ -184536,12 +184536,12 @@ pub static WORD_CONTER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_CONTEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEN_CHILDREN),
+static WORD_CONTEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEN_CHILDREN),
     value: Some(&["contain"]),
 };
 
-pub static WORD_CONTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ants"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -184619,12 +184619,12 @@ pub static WORD_CONTEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CONTEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEM_CHILDREN),
+static WORD_CONTEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("palte"),
         dictgen::InsensitiveStr::Ascii("pate"),
@@ -184656,12 +184656,12 @@ pub static WORD_CONTEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONTEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEI_CHILDREN),
+static WORD_CONTEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -184679,23 +184679,23 @@ pub static WORD_CONTEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONTED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTED_CHILDREN),
+static WORD_CONTED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTED_CHILDREN),
     value: Some(&["counted", "counter", "countered"]),
 };
 
-pub static WORD_CONTED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_CONTEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTEC_CHILDREN),
+static WORD_CONTEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("tion"),
@@ -184709,12 +184709,12 @@ pub static WORD_CONTEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTC_CHILDREN),
+static WORD_CONTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("at"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -184723,12 +184723,12 @@ pub static WORD_CONTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CONTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONTA_CHILDREN),
+static WORD_CONTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONTA_CHILDREN),
     value: None,
 };
 
-static WORD_CONTA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONTA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONTAC_NODE),
@@ -184757,12 +184757,12 @@ static WORD_CONTA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONTAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAT_CHILDREN),
+static WORD_CONTAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAT_CHILDREN),
     value: Some(&["contact"]),
 };
 
-pub static WORD_CONTAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("enate"),
@@ -184780,34 +184780,34 @@ pub static WORD_CONTAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_CONTAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAS_CHILDREN),
+static WORD_CONTAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["contacts", "contrast", "contest"]],
     range: 1..=1,
 };
 
-static WORD_CONTAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAR_CHILDREN),
+static WORD_CONTAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["contrary"]],
     range: 1..=1,
 };
 
-static WORD_CONTAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAN_CHILDREN),
+static WORD_CONTAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAN_CHILDREN),
     value: Some(&["contain"]),
 };
 
-pub static WORD_CONTAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cting"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -184851,12 +184851,12 @@ pub static WORD_CONTAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CONTAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAM_CHILDREN),
+static WORD_CONTAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inacion"),
         dictgen::InsensitiveStr::Ascii("inanted"),
@@ -184886,12 +184886,12 @@ pub static WORD_CONTAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_CONTAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAI_CHILDREN),
+static WORD_CONTAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("enr"),
@@ -184993,12 +184993,12 @@ pub static WORD_CONTAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONTAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAG_CHILDREN),
+static WORD_CONTAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONTAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("eous"),
@@ -185018,12 +185018,12 @@ pub static WORD_CONTAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_CONTAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONTAC_CHILDREN),
+static WORD_CONTAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONTAC_CHILDREN),
     value: Some(&["contact"]),
 };
 
-pub static WORD_CONTAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONTAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entaion"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -185043,12 +185043,12 @@ pub static WORD_CONTAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CONS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONS_CHILDREN),
+static WORD_CONS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONS_CHILDREN),
     value: None,
 };
 
-static WORD_CONS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONSA_NODE),
     None,
     Some(&WORD_CONSC_NODE),
@@ -185077,12 +185077,12 @@ static WORD_CONS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSU_CHILDREN),
+static WORD_CONSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -185172,12 +185172,12 @@ pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CONST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONST_CHILDREN),
+static WORD_CONST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONST_CHILDREN),
     value: None,
 };
 
-static WORD_CONST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONST_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONSTA_NODE),
     None,
     Some(&WORD_CONSTC_NODE),
@@ -185206,12 +185206,12 @@ static WORD_CONST_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTU_CHILDREN),
+static WORD_CONSTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -185249,12 +185249,12 @@ pub static WORD_CONSTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CONSTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTT_CHILDREN),
+static WORD_CONSTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ruct"),
         dictgen::InsensitiveStr::Ascii("ructer"),
@@ -185274,12 +185274,12 @@ pub static WORD_CONSTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_CONSTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONSTR_CHILDREN),
+static WORD_CONSTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONSTR_CHILDREN),
     value: None,
 };
 
-static WORD_CONSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONSTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONSTRA_NODE),
     None,
     Some(&WORD_CONSTRC_NODE),
@@ -185308,12 +185308,12 @@ static WORD_CONSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRU_CHILDREN),
+static WORD_CONSTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ccion"),
@@ -185435,12 +185435,12 @@ pub static WORD_CONSTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONSTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRO_CHILDREN),
+static WORD_CONSTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("llers"),
@@ -185449,12 +185449,12 @@ pub static WORD_CONSTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_CONSTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRI_CHILDREN),
+static WORD_CONSTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -185470,12 +185470,12 @@ pub static WORD_CONSTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_CONSTRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRC_CHILDREN),
+static WORD_CONSTRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -185511,12 +185511,12 @@ pub static WORD_CONSTRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=5,
 };
 
-static WORD_CONSTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRA_CHILDREN),
+static WORD_CONSTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -185578,45 +185578,45 @@ pub static WORD_CONSTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=6,
 };
 
-static WORD_CONSTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTO_CHILDREN),
+static WORD_CONSTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ls")],
     values: &[&["controls"]],
     range: 2..=2,
 };
 
-static WORD_CONSTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTN_CHILDREN),
+static WORD_CONSTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("atly")],
     values: &[&["constantly"]],
     range: 4..=4,
 };
 
-static WORD_CONSTL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTL_CHILDREN),
+static WORD_CONSTL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("y")],
     values: &[&["costly"]],
     range: 1..=1,
 };
 
-static WORD_CONSTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTI_CHILDREN),
+static WORD_CONSTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llation"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -185702,12 +185702,12 @@ pub static WORD_CONSTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_CONSTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTE_CHILDREN),
+static WORD_CONSTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncy"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -185723,23 +185723,23 @@ pub static WORD_CONSTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONSTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTC_CHILDREN),
+static WORD_CONSTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("urts")],
     values: &[&["constructs"]],
     range: 4..=4,
 };
 
-static WORD_CONSTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSTA_CHILDREN),
+static WORD_CONSTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -185813,12 +185813,12 @@ pub static WORD_CONSTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSR_CHILDREN),
+static WORD_CONSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tuct"),
         dictgen::InsensitiveStr::Ascii("tucted"),
@@ -185848,12 +185848,12 @@ pub static WORD_CONSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONSQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSQ_CHILDREN),
+static WORD_CONSQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("euences"),
         dictgen::InsensitiveStr::Ascii("uence"),
@@ -185871,12 +185871,12 @@ pub static WORD_CONSQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_CONSP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSP_CHILDREN),
+static WORD_CONSP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ericies"),
         dictgen::InsensitiveStr::Ascii("irace"),
@@ -185906,12 +185906,12 @@ pub static WORD_CONSP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CONSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSO_CHILDREN),
+static WORD_CONSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("l"),
@@ -185961,12 +185961,12 @@ pub static WORD_CONSO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_CONSN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSN_CHILDREN),
+static WORD_CONSN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tant"),
         dictgen::InsensitiveStr::Ascii("tantly"),
@@ -185976,12 +185976,12 @@ pub static WORD_CONSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CONSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSL_CHILDREN),
+static WORD_CONSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("utant"),
         dictgen::InsensitiveStr::Ascii("utants"),
@@ -185991,12 +185991,12 @@ pub static WORD_CONSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CONSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONSI_CHILDREN),
+static WORD_CONSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONSI_CHILDREN),
     value: None,
 };
 
-static WORD_CONSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONSI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONSIC_NODE),
@@ -186025,12 +186025,12 @@ static WORD_CONSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIT_CHILDREN),
+static WORD_CONSIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIT_CHILDREN),
     value: Some(&["consist"]),
 };
 
-pub static WORD_CONSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -186088,12 +186088,12 @@ pub static WORD_CONSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CONSIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIS_CHILDREN),
+static WORD_CONSIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -186151,12 +186151,12 @@ pub static WORD_CONSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIR_CHILDREN),
+static WORD_CONSIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -186165,23 +186165,23 @@ pub static WORD_CONSIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_CONSIQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIQ_CHILDREN),
+static WORD_CONSIQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uently")],
     values: &[&["consequently"]],
     range: 6..=6,
 };
 
-static WORD_CONSIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIP_CHILDREN),
+static WORD_CONSIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("racies"),
         dictgen::InsensitiveStr::Ascii("racy"),
@@ -186190,23 +186190,23 @@ pub static WORD_CONSIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_CONSIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIO_CHILDREN),
+static WORD_CONSIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("us")],
     values: &[&["conscious"]],
     range: 2..=2,
 };
 
-static WORD_CONSIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIL_CHILDREN),
+static WORD_CONSIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("idate"),
@@ -186216,12 +186216,12 @@ pub static WORD_CONSIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=6,
 };
 
-static WORD_CONSIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIF_CHILDREN),
+static WORD_CONSIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -186230,12 +186230,12 @@ pub static WORD_CONSIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONSIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIE_CHILDREN),
+static WORD_CONSIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("red"),
@@ -186245,12 +186245,12 @@ pub static WORD_CONSIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONSID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSID_CHILDREN),
+static WORD_CONSID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSID_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("deration"),
@@ -186340,12 +186340,12 @@ pub static WORD_CONSID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSIC_CHILDREN),
+static WORD_CONSIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -186363,23 +186363,23 @@ pub static WORD_CONSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSF_CHILDREN),
+static WORD_CONSF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icated")],
     values: &[&["confiscated"]],
     range: 6..=6,
 };
 
-static WORD_CONSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONSE_CHILDREN),
+static WORD_CONSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONSE_CHILDREN),
     value: None,
 };
 
-static WORD_CONSE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONSE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONSEA_NODE),
     None,
     Some(&WORD_CONSEC_NODE),
@@ -186408,45 +186408,45 @@ static WORD_CONSE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONSEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEV_CHILDREN),
+static WORD_CONSEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ible")],
     values: &[&["conceivable"]],
     range: 4..=4,
 };
 
-static WORD_CONSEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEU_CHILDREN),
+static WORD_CONSEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tive")],
     values: &[&["consecutive"]],
     range: 4..=4,
 };
 
-static WORD_CONSES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSES_CHILDREN),
+static WORD_CONSES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tently")],
     values: &[&["consistently"]],
     range: 6..=6,
 };
 
-static WORD_CONSER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSER_CHILDREN),
+static WORD_CONSER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSER_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ned"),
@@ -186502,12 +186502,12 @@ pub static WORD_CONSER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONSEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEQ_CHILDREN),
+static WORD_CONSEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eunces"),
         dictgen::InsensitiveStr::Ascii("uece"),
@@ -186551,12 +186551,12 @@ pub static WORD_CONSEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=9,
 };
 
-static WORD_CONSEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEP_CHILDREN),
+static WORD_CONSEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -186565,12 +186565,12 @@ pub static WORD_CONSEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_CONSEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEN_CHILDREN),
+static WORD_CONSEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("quently"),
@@ -186610,34 +186610,34 @@ pub static WORD_CONSEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CONSEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEL_CHILDREN),
+static WORD_CONSEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ation")],
     values: &[&["consolation"]],
     range: 5..=5,
 };
 
-static WORD_CONSEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEG_CHILDREN),
+static WORD_CONSEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uence")],
     values: &[&["consequence"]],
     range: 5..=5,
 };
 
-static WORD_CONSEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEE_CHILDREN),
+static WORD_CONSEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dd"),
@@ -186648,12 +186648,12 @@ pub static WORD_CONSEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONSEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEC_CHILDREN),
+static WORD_CONSEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tive"),
         dictgen::InsensitiveStr::Ascii("tively"),
@@ -186685,12 +186685,12 @@ pub static WORD_CONSEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_CONSEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSEA_CHILDREN),
+static WORD_CONSEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -186699,12 +186699,12 @@ pub static WORD_CONSEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONSD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSD_CHILDREN),
+static WORD_CONSD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ider"),
         dictgen::InsensitiveStr::Ascii("idered"),
@@ -186722,12 +186722,12 @@ pub static WORD_CONSD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSC_CHILDREN),
+static WORD_CONSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("iencious"),
@@ -186769,23 +186769,23 @@ pub static WORD_CONSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CONSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONSA_CHILDREN),
+static WORD_CONSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nts")],
     values: &[&["constants"]],
     range: 3..=3,
 };
 
-static WORD_CONR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONR_CHILDREN),
+static WORD_CONR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ete"),
         dictgen::InsensitiveStr::Ascii("ol"),
@@ -186837,12 +186837,12 @@ pub static WORD_CONR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_CONQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONQ_CHILDREN),
+static WORD_CONQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eur"),
         dictgen::InsensitiveStr::Ascii("euring"),
@@ -186872,12 +186872,12 @@ pub static WORD_CONQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONP_CHILDREN),
+static WORD_CONP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ares"),
         dictgen::InsensitiveStr::Ascii("assionate"),
@@ -186929,12 +186929,12 @@ pub static WORD_CONP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_CONO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONO_CHILDREN),
+static WORD_CONO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lization"),
         dictgen::InsensitiveStr::Ascii("ntation"),
@@ -186962,12 +186962,12 @@ pub static WORD_CONO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONN_CHILDREN),
+static WORD_CONN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONN_CHILDREN),
     value: None,
 };
 
-static WORD_CONN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONNA_NODE),
     None,
     Some(&WORD_CONNC_NODE),
@@ -186996,12 +186996,12 @@ static WORD_CONN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNT_CHILDREN),
+static WORD_CONNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ents"),
         dictgen::InsensitiveStr::Ascii("roller"),
@@ -187010,12 +187010,12 @@ pub static WORD_CONNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CONNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNS_CHILDREN),
+static WORD_CONNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("train"),
         dictgen::InsensitiveStr::Ascii("trained"),
@@ -187025,12 +187025,12 @@ pub static WORD_CONNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CONNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNO_CHILDREN),
+static WORD_CONNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nation"),
         dictgen::InsensitiveStr::Ascii("nations"),
@@ -187048,12 +187048,12 @@ pub static WORD_CONNO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_CONNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNN_CHILDREN),
+static WORD_CONNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -187073,23 +187073,23 @@ pub static WORD_CONNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNI_CHILDREN),
+static WORD_CONNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tations")],
     values: &[&["connotations"]],
     range: 7..=7,
 };
 
-static WORD_CONNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNE_CHILDREN),
+static WORD_CONNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cetd"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -187211,12 +187211,12 @@ pub static WORD_CONNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_CONNC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNC_CHILDREN),
+static WORD_CONNC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ection"),
         dictgen::InsensitiveStr::Ascii("etion"),
@@ -187236,12 +187236,12 @@ pub static WORD_CONNC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CONNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONNA_CHILDREN),
+static WORD_CONNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("tation"),
@@ -187251,12 +187251,12 @@ pub static WORD_CONNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONM_CHILDREN),
+static WORD_CONM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mutes"),
         dictgen::InsensitiveStr::Ascii("nection"),
@@ -187272,12 +187272,12 @@ pub static WORD_CONM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_CONL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONL_CHILDREN),
+static WORD_CONL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cude"),
         dictgen::InsensitiveStr::Ascii("cuded"),
@@ -187305,12 +187305,12 @@ pub static WORD_CONL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_CONJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONJ_CHILDREN),
+static WORD_CONJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecutre"),
         dictgen::InsensitiveStr::Ascii("onction"),
@@ -187340,12 +187340,12 @@ pub static WORD_CONJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_CONI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONI_CHILDREN),
+static WORD_CONI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cide"),
         dictgen::InsensitiveStr::Ascii("cidence"),
@@ -187417,12 +187417,12 @@ pub static WORD_CONI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CONG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONG_CHILDREN),
+static WORD_CONG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egration"),
         dictgen::InsensitiveStr::Ascii("ergation"),
@@ -187512,12 +187512,12 @@ pub static WORD_CONG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_CONF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONF_CHILDREN),
+static WORD_CONF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONF_CHILDREN),
     value: None,
 };
 
-static WORD_CONF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -187546,12 +187546,12 @@ static WORD_CONF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONFU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFU_CHILDREN),
+static WORD_CONFU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("cion"),
@@ -187675,12 +187675,12 @@ pub static WORD_CONFU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CONFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFR_CHILDREN),
+static WORD_CONFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("entation"),
@@ -187720,12 +187720,12 @@ pub static WORD_CONFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CONFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFO_CHILDREN),
+static WORD_CONFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("guration"),
@@ -187743,12 +187743,12 @@ pub static WORD_CONFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CONFL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFL_CHILDREN),
+static WORD_CONFL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cit"),
         dictgen::InsensitiveStr::Ascii("citing"),
@@ -187780,12 +187780,12 @@ pub static WORD_CONFL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CONFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONFI_CHILDREN),
+static WORD_CONFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONFI_CHILDREN),
     value: None,
 };
 
-static WORD_CONFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONFI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONFIC_NODE),
@@ -187814,12 +187814,12 @@ static WORD_CONFI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONFIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIU_CHILDREN),
+static WORD_CONFIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("grable"),
@@ -187849,23 +187849,23 @@ pub static WORD_CONFIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONFIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIT_CHILDREN),
+static WORD_CONFIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uration")],
     values: &[&["configuration"]],
     range: 7..=7,
 };
 
-static WORD_CONFIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIS_CHILDREN),
+static WORD_CONFIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("gated"),
@@ -187874,12 +187874,12 @@ pub static WORD_CONFIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_CONFIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIR_CHILDREN),
+static WORD_CONFIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIR_CHILDREN),
     value: Some(&["confirm"]),
 };
 
-pub static WORD_CONFIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amtion"),
         dictgen::InsensitiveStr::Ascii("macion"),
@@ -187911,12 +187911,12 @@ pub static WORD_CONFIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CONFIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIN_CHILDREN),
+static WORD_CONFIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("gs"),
@@ -187934,12 +187934,12 @@ pub static WORD_CONFIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONFIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIM_CHILDREN),
+static WORD_CONFIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIM_CHILDREN),
     value: Some(&["confirm"]),
 };
 
-pub static WORD_CONFIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -187963,12 +187963,12 @@ pub static WORD_CONFIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_CONFIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIL_CHILDREN),
+static WORD_CONFIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cting"),
@@ -187978,12 +187978,12 @@ pub static WORD_CONFIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_CONFIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONFIG_CHILDREN),
+static WORD_CONFIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONFIG_CHILDREN),
     value: None,
 };
 
-static WORD_CONFIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONFIG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONFIGA_NODE),
     None,
     None,
@@ -188012,12 +188012,12 @@ static WORD_CONFIG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONFIGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGU_CHILDREN),
+static WORD_CONFIGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aration"),
         dictgen::InsensitiveStr::Ascii("arble"),
@@ -188137,12 +188137,12 @@ pub static WORD_CONFIGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=8,
 };
 
-static WORD_CONFIGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGR_CHILDREN),
+static WORD_CONFIGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -188166,23 +188166,23 @@ pub static WORD_CONFIGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=7,
 };
 
-static WORD_CONFIGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGL_CHILDREN),
+static WORD_CONFIGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGL_CHILDREN),
     value: Some(&["config"]),
 };
 
-pub static WORD_CONFIGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_CONFIGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGI_CHILDREN),
+static WORD_CONFIGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("guration"),
         dictgen::InsensitiveStr::Ascii("ration"),
@@ -188198,12 +188198,12 @@ pub static WORD_CONFIGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_CONFIGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGE_CHILDREN),
+static WORD_CONFIGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("r"),
@@ -188212,23 +188212,23 @@ pub static WORD_CONFIGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=1,
 };
 
-static WORD_CONFIGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGA_CHILDREN),
+static WORD_CONFIGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ration")],
     values: &[&["configuration"]],
     range: 6..=6,
 };
 
-static WORD_CONFIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIF_CHILDREN),
+static WORD_CONFIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("urable"),
         dictgen::InsensitiveStr::Ascii("uration"),
@@ -188244,12 +188244,12 @@ pub static WORD_CONFIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=7,
 };
 
-static WORD_CONFID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFID_CHILDREN),
+static WORD_CONFID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFID_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("antal"),
@@ -188299,12 +188299,12 @@ pub static WORD_CONFID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_CONFIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFIC_CHILDREN),
+static WORD_CONFIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ted"),
@@ -188320,12 +188320,12 @@ pub static WORD_CONFIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_CONFG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFG_CHILDREN),
+static WORD_CONFG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("iuration"),
@@ -188347,12 +188347,12 @@ pub static WORD_CONFG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CONFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFF_CHILDREN),
+static WORD_CONFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ig"),
         dictgen::InsensitiveStr::Ascii("iguration"),
@@ -188361,12 +188361,12 @@ pub static WORD_CONFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CONFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONFE_CHILDREN),
+static WORD_CONFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONFE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daracy"),
         dictgen::InsensitiveStr::Ascii("darate"),
@@ -188436,12 +188436,12 @@ pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_CONE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONE_CHILDREN),
+static WORD_CONE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONE_CHILDREN),
     value: None,
 };
 
-static WORD_CONE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CONEC_NODE),
@@ -188470,12 +188470,12 @@ static WORD_CONE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONEX_CHILDREN),
+static WORD_CONEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONEX_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -188489,12 +188489,12 @@ pub static WORD_CONEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CONET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONET_CHILDREN),
+static WORD_CONET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONET_CHILDREN),
     value: Some(&["connect"]),
 };
 
-pub static WORD_CONET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -188526,12 +188526,12 @@ pub static WORD_CONET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_CONES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONES_CHILDREN),
+static WORD_CONES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cutive"),
         dictgen::InsensitiveStr::Ascii("encus"),
@@ -188540,12 +188540,12 @@ pub static WORD_CONES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CONER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONER_CHILDREN),
+static WORD_CONER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONER_CHILDREN),
     value: Some(&["corner", "coroner"]),
 };
 
-pub static WORD_CONER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gence"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -188577,12 +188577,12 @@ pub static WORD_CONER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CONEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONEN_CHILDREN),
+static WORD_CONEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -188624,12 +188624,12 @@ pub static WORD_CONEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CONEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONEE_CHILDREN),
+static WORD_CONEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -188657,12 +188657,12 @@ pub static WORD_CONEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CONEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONEC_CHILDREN),
+static WORD_CONEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -188740,12 +188740,12 @@ pub static WORD_CONEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COND_CHILDREN),
+static WORD_COND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COND_CHILDREN),
     value: None,
 };
 
-static WORD_COND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COND_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONDA_NODE),
     None,
     None,
@@ -188774,12 +188774,12 @@ static WORD_COND_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONDU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDU_CHILDREN),
+static WORD_CONDU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctiong"),
         dictgen::InsensitiveStr::Ascii("ctuve"),
@@ -188799,12 +188799,12 @@ pub static WORD_CONDU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CONDT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDT_CHILDREN),
+static WORD_CONDT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iion"),
         dictgen::InsensitiveStr::Ascii("iions"),
@@ -188836,12 +188836,12 @@ pub static WORD_CONDT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CONDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDR_CHILDREN),
+static WORD_CONDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adicted"),
         dictgen::InsensitiveStr::Ascii("adicting"),
@@ -188859,12 +188859,12 @@ pub static WORD_CONDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_CONDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDO_CHILDREN),
+static WORD_CONDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lances"),
         dictgen::InsensitiveStr::Ascii("lencies"),
@@ -188888,23 +188888,23 @@ pub static WORD_CONDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONDN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDN_CHILDREN),
+static WORD_CONDN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tional")],
     values: &[&["conditional"]],
     range: 6..=6,
 };
 
-static WORD_CONDM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDM_CHILDREN),
+static WORD_CONDM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("en"),
         dictgen::InsensitiveStr::Ascii("enation"),
@@ -188920,12 +188920,12 @@ pub static WORD_CONDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CONDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDI_CHILDREN),
+static WORD_CONDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cional"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -189027,12 +189027,12 @@ pub static WORD_CONDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CONDF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDF_CHILDREN),
+static WORD_CONDF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iguration"),
         dictgen::InsensitiveStr::Ascii("igurations"),
@@ -189052,12 +189052,12 @@ pub static WORD_CONDF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=10,
 };
 
-static WORD_CONDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDE_CHILDREN),
+static WORD_CONDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("feracy"),
         dictgen::InsensitiveStr::Ascii("m"),
@@ -189109,12 +189109,12 @@ pub static WORD_CONDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CONDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONDA_CHILDREN),
+static WORD_CONDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mnation"),
         dictgen::InsensitiveStr::Ascii("mned"),
@@ -189130,12 +189130,12 @@ pub static WORD_CONDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONC_CHILDREN),
+static WORD_CONC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONC_CHILDREN),
     value: None,
 };
 
-static WORD_CONC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONCA_NODE),
     None,
     None,
@@ -189164,12 +189164,12 @@ static WORD_CONC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCU_CHILDREN),
+static WORD_CONCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lsion"),
         dictgen::InsensitiveStr::Ascii("lsions"),
@@ -189219,23 +189219,23 @@ pub static WORD_CONCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CONCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCT_CHILDREN),
+static WORD_CONCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ats")],
     values: &[&["contacts"]],
     range: 3..=3,
 };
 
-static WORD_CONCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCS_CHILDREN),
+static WORD_CONCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ience"),
         dictgen::InsensitiveStr::Ascii("ious"),
@@ -189251,12 +189251,12 @@ pub static WORD_CONCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CONCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCR_CHILDREN),
+static WORD_CONCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eet"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -189266,12 +189266,12 @@ pub static WORD_CONCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CONCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCO_CHILDREN),
+static WORD_CONCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("rrent"),
@@ -189280,23 +189280,23 @@ pub static WORD_CONCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CONCN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCN_CHILDREN),
+static WORD_CONCN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etration")],
     values: &[&["concentrations"]],
     range: 8..=8,
 };
 
-static WORD_CONCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCL_CHILDREN),
+static WORD_CONCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eanment"),
         dictgen::InsensitiveStr::Ascii("suion"),
@@ -189336,12 +189336,12 @@ pub static WORD_CONCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CONCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCI_CHILDREN),
+static WORD_CONCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bes"),
         dictgen::InsensitiveStr::Ascii("cely"),
@@ -189393,12 +189393,12 @@ pub static WORD_CONCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CONCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCH_CHILDREN),
+static WORD_CONCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ances"),
@@ -189416,12 +189416,12 @@ pub static WORD_CONCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CONCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CONCE_CHILDREN),
+static WORD_CONCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CONCE_CHILDREN),
     value: None,
 };
 
-static WORD_CONCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CONCE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CONCEA_NODE),
     None,
     Some(&WORD_CONCEC_NODE),
@@ -189450,12 +189450,12 @@ static WORD_CONCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CONCEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEV_CHILDREN),
+static WORD_CONCEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("iable"),
@@ -189471,23 +189471,23 @@ pub static WORD_CONCEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_CONCET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCET_CHILDREN),
+static WORD_CONCET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCET_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["concede"]],
     range: 2..=2,
 };
 
-static WORD_CONCES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCES_CHILDREN),
+static WORD_CONCES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ions"),
         dictgen::InsensitiveStr::Ascii("so"),
@@ -189496,12 +189496,12 @@ pub static WORD_CONCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_CONCER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCER_CHILDREN),
+static WORD_CONCER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCER_CHILDREN),
     value: Some(&["concern"]),
 };
 
-pub static WORD_CONCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("end"),
@@ -189543,12 +189543,12 @@ pub static WORD_CONCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=8,
 };
 
-static WORD_CONCEQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEQ_CHILDREN),
+static WORD_CONCEQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uence"),
         dictgen::InsensitiveStr::Ascii("uences"),
@@ -189564,12 +189564,12 @@ pub static WORD_CONCEQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_CONCEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEP_CHILDREN),
+static WORD_CONCEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("ta"),
@@ -189593,12 +189593,12 @@ pub static WORD_CONCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=10,
 };
 
-static WORD_CONCEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEO_CHILDREN),
+static WORD_CONCEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("us"),
         dictgen::InsensitiveStr::Ascii("usally"),
@@ -189608,12 +189608,12 @@ pub static WORD_CONCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CONCEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEN_CHILDREN),
+static WORD_CONCEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("crate"),
         dictgen::InsensitiveStr::Ascii("cration"),
@@ -189685,12 +189685,12 @@ pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CONCEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEL_CHILDREN),
+static WORD_CONCEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aed"),
         dictgen::InsensitiveStr::Ascii("aer"),
@@ -189708,12 +189708,12 @@ pub static WORD_CONCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CONCEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEI_CHILDREN),
+static WORD_CONCEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("tual"),
@@ -189731,12 +189731,12 @@ pub static WORD_CONCEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CONCEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEE_CHILDREN),
+static WORD_CONCEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dd"),
@@ -189747,12 +189747,12 @@ pub static WORD_CONCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=3,
 };
 
-static WORD_CONCED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCED_CHILDREN),
+static WORD_CONCED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("endo"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -189761,34 +189761,34 @@ pub static WORD_CONCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=4,
 };
 
-static WORD_CONCEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEC_CHILDREN),
+static WORD_CONCEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utive")],
     values: &[&["consecutive"]],
     range: 5..=5,
 };
 
-static WORD_CONCEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCEA_CHILDREN),
+static WORD_CONCEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ld")],
     values: &[&["concealed"]],
     range: 2..=2,
 };
 
-static WORD_CONCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONCA_CHILDREN),
+static WORD_CONCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nented"),
         dictgen::InsensitiveStr::Ascii("neted"),
@@ -189852,12 +189852,12 @@ pub static WORD_CONCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_CONB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONB_CHILDREN),
+static WORD_CONB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ination"),
         dictgen::InsensitiveStr::Ascii("inations"),
@@ -189875,12 +189875,12 @@ pub static WORD_CONB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CONA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CONA_CHILDREN),
+static WORD_CONA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CONA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CONA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -189934,12 +189934,12 @@ pub static WORD_CONA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COM_CHILDREN),
+static WORD_COM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COM_CHILDREN),
     value: None,
 };
 
-static WORD_COM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMA_NODE),
     Some(&WORD_COMB_NODE),
     Some(&WORD_COMC_NODE),
@@ -189968,12 +189968,12 @@ static WORD_COM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMV_CHILDREN),
+static WORD_COMV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMV_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entions"),
         dictgen::InsensitiveStr::Ascii("ersion"),
@@ -189983,12 +189983,12 @@ pub static WORD_COMV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_COMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMU_CHILDREN),
+static WORD_COMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nicate"),
         dictgen::InsensitiveStr::Ascii("nicating"),
@@ -190024,12 +190024,12 @@ pub static WORD_COMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_COMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMT_CHILDREN),
+static WORD_COMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ained"),
@@ -190057,12 +190057,12 @@ pub static WORD_COMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_COMS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMS_CHILDREN),
+static WORD_COMS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etic"),
         dictgen::InsensitiveStr::Ascii("etics"),
@@ -190096,12 +190096,12 @@ pub static WORD_COMS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_COMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMR_CHILDREN),
+static WORD_COMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adets"),
         dictgen::InsensitiveStr::Ascii("adre"),
@@ -190139,12 +190139,12 @@ pub static WORD_COMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_COMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMP_CHILDREN),
+static WORD_COMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMP_CHILDREN),
     value: None,
 };
 
-static WORD_COMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMPA_NODE),
     None,
     None,
@@ -190173,12 +190173,12 @@ static WORD_COMP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPU_CHILDREN),
+static WORD_COMPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atation"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -190258,12 +190258,12 @@ pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_COMPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPT_CHILDREN),
+static WORD_COMPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abile"),
         dictgen::InsensitiveStr::Ascii("ability"),
@@ -190293,12 +190293,12 @@ pub static WORD_COMPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COMPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPS_CHILDREN),
+static WORD_COMPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -190308,12 +190308,12 @@ pub static WORD_COMPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_COMPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPR_CHILDREN),
+static WORD_COMPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("aison"),
@@ -190439,12 +190439,12 @@ pub static WORD_COMPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_COMPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPP_CHILDREN),
+static WORD_COMPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atible"),
         dictgen::InsensitiveStr::Ascii("iler"),
@@ -190460,12 +190460,12 @@ pub static WORD_COMPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_COMPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPO_CHILDREN),
+static WORD_COMPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPO_CHILDREN),
     value: None,
 };
 
-static WORD_COMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -190494,23 +190494,23 @@ static WORD_COMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOU_CHILDREN),
+static WORD_COMPOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nt")],
     values: &[&["compound"]],
     range: 2..=2,
 };
 
-static WORD_COMPOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOT_CHILDREN),
+static WORD_COMPOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -190519,12 +190519,12 @@ pub static WORD_COMPOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_COMPOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOS_CHILDREN),
+static WORD_COMPOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ablity"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -190586,12 +190586,12 @@ pub static WORD_COMPOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=9,
 };
 
-static WORD_COMPOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOR_CHILDREN),
+static WORD_COMPOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ession"),
@@ -190600,12 +190600,12 @@ pub static WORD_COMPOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_COMPOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOO_CHILDREN),
+static WORD_COMPOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nent"),
         dictgen::InsensitiveStr::Ascii("nents"),
@@ -190614,12 +190614,12 @@ pub static WORD_COMPOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_COMPON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPON_CHILDREN),
+static WORD_COMPON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPON_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ants"),
@@ -190685,12 +190685,12 @@ pub static WORD_COMPON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_COMPOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOM_CHILDREN),
+static WORD_COMPOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -190699,12 +190699,12 @@ pub static WORD_COMPOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_COMPOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOL_CHILDREN),
+static WORD_COMPOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("sive"),
@@ -190720,12 +190720,12 @@ pub static WORD_COMPOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_COMPOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPOE_CHILDREN),
+static WORD_COMPOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nents"),
         dictgen::InsensitiveStr::Ascii("nnt"),
@@ -190743,12 +190743,12 @@ pub static WORD_COMPOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_COMPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPN_CHILDREN),
+static WORD_COMPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aies"),
         dictgen::InsensitiveStr::Ascii("ay"),
@@ -190766,12 +190766,12 @@ pub static WORD_COMPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_COMPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPL_CHILDREN),
+static WORD_COMPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPL_CHILDREN),
     value: None,
 };
 
-static WORD_COMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMPLA_NODE),
     None,
     Some(&WORD_COMPLC_NODE),
@@ -190800,23 +190800,23 @@ static WORD_COMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLY_CHILDREN),
+static WORD_COMPLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("s")],
     values: &[&["complies"]],
     range: 1..=1,
 };
 
-static WORD_COMPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLU_CHILDREN),
+static WORD_COMPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sion"),
         dictgen::InsensitiveStr::Ascii("sions"),
@@ -190834,12 +190834,12 @@ pub static WORD_COMPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_COMPLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLT_CHILDREN),
+static WORD_COMPLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -190848,23 +190848,23 @@ pub static WORD_COMPLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=2,
 };
 
-static WORD_COMPLM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLM_CHILDREN),
+static WORD_COMPLM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enet")],
     values: &[&["complement"]],
     range: 4..=4,
 };
 
-static WORD_COMPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLI_CHILDREN),
+static WORD_COMPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -190988,12 +190988,12 @@ pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=9,
 };
 
-static WORD_COMPLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLE_CHILDREN),
+static WORD_COMPLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLE_CHILDREN),
     value: Some(&["complete"]),
 };
 
-pub static WORD_COMPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -191127,12 +191127,12 @@ pub static WORD_COMPLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_COMPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLC_CHILDREN),
+static WORD_COMPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -191142,12 +191142,12 @@ pub static WORD_COMPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_COMPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPLA_CHILDREN),
+static WORD_COMPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cant"),
         dictgen::InsensitiveStr::Ascii("cient"),
@@ -191195,12 +191195,12 @@ pub static WORD_COMPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_COMPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPI_CHILDREN),
+static WORD_COMPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("ation"),
@@ -191322,34 +191322,34 @@ pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COMPH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPH_CHILDREN),
+static WORD_COMPH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPH_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rehensive")],
     values: &[&["comprehensive"]],
     range: 9..=9,
 };
 
-static WORD_COMPF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPF_CHILDREN),
+static WORD_COMPF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPF_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ortable")],
     values: &[&["comfortable"]],
     range: 7..=7,
 };
 
-static WORD_COMPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPE_CHILDREN),
+static WORD_COMPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPE_CHILDREN),
     value: None,
 };
 
-static WORD_COMPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMPEA_NODE),
     None,
     None,
@@ -191378,23 +191378,23 @@ static WORD_COMPE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPEX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEX_CHILDREN),
+static WORD_COMPEX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEX_CHILDREN),
     value: Some(&["complex"]),
 };
 
-pub static WORD_COMPEX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_COMPET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPET_CHILDREN),
+static WORD_COMPET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPET_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ant"),
@@ -191492,12 +191492,12 @@ pub static WORD_COMPET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=8,
 };
 
-static WORD_COMPES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPES_CHILDREN),
+static WORD_COMPES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPES_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ition"),
         dictgen::InsensitiveStr::Ascii("itions"),
@@ -191507,12 +191507,12 @@ pub static WORD_COMPES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_COMPER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPER_CHILDREN),
+static WORD_COMPER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPER_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -191530,12 +191530,12 @@ pub static WORD_COMPER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_COMPEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEN_CHILDREN),
+static WORD_COMPEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("duim"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -191577,23 +191577,23 @@ pub static WORD_COMPEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_COMPEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEM_CHILDREN),
+static WORD_COMPEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dium")],
     values: &[&["compendium"]],
     range: 4..=4,
 };
 
-static WORD_COMPEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEL_CHILDREN),
+static WORD_COMPEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ete"),
@@ -191633,12 +191633,12 @@ pub static WORD_COMPEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=6,
 };
 
-static WORD_COMPEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEI_CHILDREN),
+static WORD_COMPEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tion"),
         dictgen::InsensitiveStr::Ascii("tions"),
@@ -191648,23 +191648,23 @@ pub static WORD_COMPEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=5,
 };
 
-static WORD_COMPEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEE_CHILDREN),
+static WORD_COMPEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ting")],
     values: &[&["completing"]],
     range: 4..=4,
 };
 
-static WORD_COMPED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPED_CHILDREN),
+static WORD_COMPED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPED_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("itive"),
@@ -191684,12 +191684,12 @@ pub static WORD_COMPED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_COMPEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPEA_CHILDREN),
+static WORD_COMPEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("re"),
         dictgen::InsensitiveStr::Ascii("red"),
@@ -191715,12 +191715,12 @@ pub static WORD_COMPEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_COMPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPA_CHILDREN),
+static WORD_COMPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPA_CHILDREN),
     value: None,
 };
 
-static WORD_COMPA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_COMPAB_NODE),
     Some(&WORD_COMPAC_NODE),
@@ -191749,23 +191749,23 @@ static WORD_COMPA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAY_CHILDREN),
+static WORD_COMPAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAY_CHILDREN),
     value: Some(&["company"]),
 };
 
-pub static WORD_COMPAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tibility")],
     values: &[&["compatibility"]],
     range: 8..=8,
 };
 
-static WORD_COMPAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAT_CHILDREN),
+static WORD_COMPAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abable"),
         dictgen::InsensitiveStr::Ascii("abiity"),
@@ -191873,12 +191873,12 @@ pub static WORD_COMPAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_COMPAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAS_CHILDREN),
+static WORD_COMPAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("sione"),
@@ -191894,12 +191894,12 @@ pub static WORD_COMPAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=5,
 };
 
-static WORD_COMPAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMPAR_CHILDREN),
+static WORD_COMPAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMPAR_CHILDREN),
     value: None,
 };
 
-static WORD_COMPAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMPAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMPARA_NODE),
     None,
     None,
@@ -191928,12 +191928,12 @@ static WORD_COMPAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMPART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPART_CHILDREN),
+static WORD_COMPART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPART_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ent"),
@@ -191943,12 +191943,12 @@ pub static WORD_COMPART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=3,
 };
 
-static WORD_COMPARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARS_CHILDREN),
+static WORD_COMPARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -191958,23 +191958,23 @@ pub static WORD_COMPARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=4,
 };
 
-static WORD_COMPARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARR_CHILDREN),
+static WORD_COMPARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["compare"]],
     range: 1..=1,
 };
 
-static WORD_COMPARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARO_CHILDREN),
+static WORD_COMPARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tor"),
         dictgen::InsensitiveStr::Ascii("tors"),
@@ -191983,23 +191983,23 @@ pub static WORD_COMPARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_COMPARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARM_CHILDREN),
+static WORD_COMPARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ent")],
     values: &[&["compartment"]],
     range: 3..=3,
 };
 
-static WORD_COMPARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARI_CHILDREN),
+static WORD_COMPARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -192111,12 +192111,12 @@ pub static WORD_COMPARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=8,
 };
 
-static WORD_COMPARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARE_CHILDREN),
+static WORD_COMPARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -192144,12 +192144,12 @@ pub static WORD_COMPARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=6,
 };
 
-static WORD_COMPARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPARA_CHILDREN),
+static WORD_COMPARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bil"),
         dictgen::InsensitiveStr::Ascii("bile"),
@@ -192187,12 +192187,12 @@ pub static WORD_COMPARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=6,
 };
 
-static WORD_COMPAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAN_CHILDREN),
+static WORD_COMPAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dium"),
         dictgen::InsensitiveStr::Ascii("ians"),
@@ -192224,12 +192224,12 @@ pub static WORD_COMPAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_COMPAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAL_CHILDREN),
+static WORD_COMPAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -192245,12 +192245,12 @@ pub static WORD_COMPAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_COMPAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAI_CHILDREN),
+static WORD_COMPAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -192288,12 +192288,12 @@ pub static WORD_COMPAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_COMPAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAG_CHILDREN),
+static WORD_COMPAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nion"),
         dictgen::InsensitiveStr::Ascii("nons"),
@@ -192303,12 +192303,12 @@ pub static WORD_COMPAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_COMPAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAD_CHILDREN),
+static WORD_COMPAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibility"),
         dictgen::InsensitiveStr::Ascii("ible"),
@@ -192317,23 +192317,23 @@ pub static WORD_COMPAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_COMPAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAC_CHILDREN),
+static WORD_COMPAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tible")],
     values: &[&["compactable"]],
     range: 5..=5,
 };
 
-static WORD_COMPAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMPAB_CHILDREN),
+static WORD_COMPAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMPAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMPAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMPAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibility"),
         dictgen::InsensitiveStr::Ascii("ility"),
@@ -192353,12 +192353,12 @@ pub static WORD_COMPAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=7,
 };
 
-static WORD_COMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMO_CHILDREN),
+static WORD_COMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dore"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -192384,12 +192384,12 @@ pub static WORD_COMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_COMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMN_CHILDREN),
+static WORD_COMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mand"),
         dictgen::InsensitiveStr::Ascii("nected"),
@@ -192409,12 +192409,12 @@ pub static WORD_COMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_COMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COMM_CHILDREN),
+static WORD_COMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COMM_CHILDREN),
     value: None,
 };
 
-static WORD_COMM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COMM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COMMA_NODE),
     None,
     None,
@@ -192443,12 +192443,12 @@ static WORD_COMM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COMMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMU_CHILDREN),
+static WORD_COMMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ication"),
@@ -192580,12 +192580,12 @@ pub static WORD_COMMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_COMMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMT_CHILDREN),
+static WORD_COMMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMT_CHILDREN),
     value: Some(&["commit"]),
 };
 
-pub static WORD_COMMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("iment"),
@@ -192603,12 +192603,12 @@ pub static WORD_COMMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_COMMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMP_CHILDREN),
+static WORD_COMMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("action"),
@@ -192690,12 +192690,12 @@ pub static WORD_COMMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COMMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMO_CHILDREN),
+static WORD_COMMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dites"),
         dictgen::InsensitiveStr::Ascii("ditites"),
@@ -192737,12 +192737,12 @@ pub static WORD_COMMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_COMMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMN_CHILDREN),
+static WORD_COMMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ad"),
@@ -192808,12 +192808,12 @@ pub static WORD_COMMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COMMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMM_CHILDREN),
+static WORD_COMMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("and"),
@@ -192877,12 +192877,12 @@ pub static WORD_COMMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COMMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMI_CHILDREN),
+static WORD_COMMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -192992,12 +192992,12 @@ pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_COMME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMME_CHILDREN),
+static WORD_COMME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMME_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cen"),
         dictgen::InsensitiveStr::Ascii("ct"),
@@ -193117,12 +193117,12 @@ pub static WORD_COMME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_COMMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMMA_CHILDREN),
+static WORD_COMMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dline"),
@@ -193196,12 +193196,12 @@ pub static WORD_COMMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_COML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COML_CHILDREN),
+static WORD_COML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COML_CHILDREN),
     value: None,
 };
 
-pub static WORD_COML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ained"),
@@ -193241,12 +193241,12 @@ pub static WORD_COML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_COMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMI_CHILDREN),
+static WORD_COMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("led"),
@@ -193320,12 +193320,12 @@ pub static WORD_COMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_COMF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMF_CHILDREN),
+static WORD_COMF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMF_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ertable"),
         dictgen::InsensitiveStr::Ascii("ertably"),
@@ -193385,12 +193385,12 @@ pub static WORD_COMF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_COME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COME_CHILDREN),
+static WORD_COME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COME_CHILDREN),
     value: None,
 };
 
-pub static WORD_COME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cted"),
@@ -193460,12 +193460,12 @@ pub static WORD_COME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_COMD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMD_CHILDREN),
+static WORD_COMD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eic"),
         dictgen::InsensitiveStr::Ascii("emnation"),
@@ -193474,23 +193474,23 @@ pub static WORD_COMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_COMC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMC_CHILDREN),
+static WORD_COMC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eptually")],
     values: &[&["conceptually"]],
     range: 8..=8,
 };
 
-static WORD_COMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMB_CHILDREN),
+static WORD_COMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("ack"),
@@ -193590,12 +193590,12 @@ pub static WORD_COMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_COMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COMA_CHILDREN),
+static WORD_COMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dres"),
         dictgen::InsensitiveStr::Ascii("mmand"),
@@ -193693,12 +193693,12 @@ pub static WORD_COMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_COL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COL_CHILDREN),
+static WORD_COL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COL_CHILDREN),
     value: None,
 };
 
-static WORD_COL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COLA_NODE),
     None,
     None,
@@ -193727,12 +193727,12 @@ static WORD_COL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLU_CHILDREN),
+static WORD_COLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bmia"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -193782,23 +193782,23 @@ pub static WORD_COLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_COLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLS_CHILDREN),
+static WORD_COLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["closed"]],
     range: 2..=2,
 };
 
-static WORD_COLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLO_CHILDREN),
+static WORD_COLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ardo"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -193890,12 +193890,12 @@ pub static WORD_COLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COLM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLM_CHILDREN),
+static WORD_COLM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLM_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -193905,12 +193905,12 @@ pub static WORD_COLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_COLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COLL_CHILDREN),
+static WORD_COLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COLL_CHILDREN),
     value: None,
 };
 
-static WORD_COLL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COLL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COLLA_NODE),
     Some(&WORD_COLLB_NODE),
     Some(&WORD_COLLC_NODE),
@@ -193939,12 +193939,12 @@ static WORD_COLL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COLLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLU_CHILDREN),
+static WORD_COLLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mn"),
         dictgen::InsensitiveStr::Ascii("mns"),
@@ -193953,12 +193953,12 @@ pub static WORD_COLLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_COLLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLS_CHILDREN),
+static WORD_COLLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ion"),
         dictgen::InsensitiveStr::Ascii("ions"),
@@ -193967,12 +193967,12 @@ pub static WORD_COLLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_COLLP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLP_CHILDREN),
+static WORD_COLLP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLP_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ased"),
@@ -193988,12 +193988,12 @@ pub static WORD_COLLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_COLLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLO_CHILDREN),
+static WORD_COLLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("barate"),
         dictgen::InsensitiveStr::Ascii("baration"),
@@ -194031,12 +194031,12 @@ pub static WORD_COLLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COLLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLL_CHILDREN),
+static WORD_COLLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apses"),
         dictgen::InsensitiveStr::Ascii("ect"),
@@ -194046,12 +194046,12 @@ pub static WORD_COLLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_COLLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLI_CHILDREN),
+static WORD_COLLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dies"),
         dictgen::InsensitiveStr::Ascii("quial"),
@@ -194085,23 +194085,23 @@ pub static WORD_COLLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_COLLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLG_CHILDREN),
+static WORD_COLLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["college"]],
     range: 1..=1,
 };
 
-static WORD_COLLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLE_CHILDREN),
+static WORD_COLLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -194203,34 +194203,34 @@ pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_COLLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLC_CHILDREN),
+static WORD_COLLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etion")],
     values: &[&["collections"]],
     range: 5..=5,
 };
 
-static WORD_COLLB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLB_CHILDREN),
+static WORD_COLLB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLB_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orative")],
     values: &[&["collaborative"]],
     range: 7..=7,
 };
 
-static WORD_COLLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLLA_CHILDREN),
+static WORD_COLLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("barate"),
         dictgen::InsensitiveStr::Ascii("baration"),
@@ -194330,12 +194330,12 @@ pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_COLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLI_CHILDREN),
+static WORD_COLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -194345,23 +194345,23 @@ pub static WORD_COLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_COLG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLG_CHILDREN),
+static WORD_COLG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("one")],
     values: &[&["cologne"]],
     range: 3..=3,
 };
 
-static WORD_COLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLE_CHILDREN),
+static WORD_COLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agues"),
         dictgen::InsensitiveStr::Ascii("asing"),
@@ -194411,23 +194411,23 @@ pub static WORD_COLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COLD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLD_CHILDREN),
+static WORD_COLD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("plg")],
     values: &[&["coldplug"]],
     range: 3..=3,
 };
 
-static WORD_COLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COLA_CHILDREN),
+static WORD_COLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("borate"),
         dictgen::InsensitiveStr::Ascii("boration"),
@@ -194449,23 +194449,23 @@ pub static WORD_COLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_COK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COK_CHILDREN),
+static WORD_COK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COK_CHILDREN),
     value: None,
 };
 
-pub static WORD_COK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ies")],
     values: &[&["cookies"]],
     range: 3..=3,
 };
 
-static WORD_COI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COI_CHILDREN),
+static WORD_COI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COI_CHILDREN),
     value: None,
 };
 
-pub static WORD_COI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ncedental"),
@@ -194533,12 +194533,12 @@ pub static WORD_COI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_COH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COH_CHILDREN),
+static WORD_COH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COH_CHILDREN),
     value: None,
 };
 
-pub static WORD_COH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abitating"),
         dictgen::InsensitiveStr::Ascii("erance"),
@@ -194558,12 +194558,12 @@ pub static WORD_COH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_COG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COG_CHILDREN),
+static WORD_COG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COG_CHILDREN),
     value: None,
 };
 
-pub static WORD_COG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egen"),
         dictgen::InsensitiveStr::Ascii("into"),
@@ -194583,12 +194583,12 @@ pub static WORD_COG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_COF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COF_CHILDREN),
+static WORD_COF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COF_CHILDREN),
     value: None,
 };
 
-pub static WORD_COF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ee"),
         dictgen::InsensitiveStr::Ascii("eee"),
@@ -194648,12 +194648,12 @@ pub static WORD_COF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_COE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COE_CHILDREN),
+static WORD_COE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efficients"),
         dictgen::InsensitiveStr::Ascii("ffcient"),
@@ -194749,12 +194749,12 @@ pub static WORD_COE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_COD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COD_CHILDREN),
+static WORD_COD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COD_CHILDREN),
     value: None,
 };
 
-pub static WORD_COD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("de"),
         dictgen::InsensitiveStr::Ascii("een"),
@@ -194804,12 +194804,12 @@ pub static WORD_COD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_COC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COC_CHILDREN),
+static WORD_COC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atenated"),
         dictgen::InsensitiveStr::Ascii("cinele"),
@@ -194861,12 +194861,12 @@ pub static WORD_COC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_COB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COB_CHILDREN),
+static WORD_COB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COB_CHILDREN),
     value: None,
 };
 
-pub static WORD_COB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ining"),
         dictgen::InsensitiveStr::Ascii("vers"),
@@ -194875,12 +194875,12 @@ pub static WORD_COB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_COA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COA_CHILDREN),
+static WORD_COA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COA_CHILDREN),
     value: None,
 };
 
-static WORD_COA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_COAC_NODE),
@@ -194909,23 +194909,23 @@ static WORD_COA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COAS_CHILDREN),
+static WORD_COAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lescing")],
     values: &[&["coalescing"]],
     range: 7..=7,
 };
 
-static WORD_COAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_COAL_CHILDREN),
+static WORD_COAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_COAL_CHILDREN),
     value: None,
 };
 
-static WORD_COAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_COAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_COALA_NODE),
     None,
     Some(&WORD_COALC_NODE),
@@ -194954,12 +194954,12 @@ static WORD_COAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_COALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALS_CHILDREN),
+static WORD_COALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cece"),
@@ -194985,12 +194985,12 @@ pub static WORD_COALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_COALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALL_CHILDREN),
+static WORD_COALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALL_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ates"),
@@ -195062,12 +195062,12 @@ pub static WORD_COALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALE_CHILDREN),
+static WORD_COALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sc"),
         dictgen::InsensitiveStr::Ascii("scsing"),
@@ -195095,12 +195095,12 @@ pub static WORD_COALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_COALC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALC_CHILDREN),
+static WORD_COALC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ece"),
         dictgen::InsensitiveStr::Ascii("ence"),
@@ -195109,12 +195109,12 @@ pub static WORD_COALC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_COALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COALA_CHILDREN),
+static WORD_COALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_COALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cece"),
@@ -195156,23 +195156,23 @@ pub static WORD_COALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_COAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_COAC_CHILDREN),
+static WORD_COAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_COAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_COAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_COAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hig")],
     values: &[&["coaching"]],
     range: 3..=3,
 };
 
-static WORD_CN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CN_CHILDREN),
+static WORD_CN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("annel"),
@@ -195212,12 +195212,12 @@ pub static WORD_CN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_CM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CM_CHILDREN),
+static WORD_CM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("mand"),
@@ -195243,12 +195243,12 @@ pub static WORD_CM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_CL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CL_CHILDREN),
+static WORD_CL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CL_CHILDREN),
     value: None,
 };
 
-static WORD_CL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CLA_NODE),
     None,
     Some(&WORD_CLC_NODE),
@@ -195277,12 +195277,12 @@ static WORD_CL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLY_CHILDREN),
+static WORD_CLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amore"),
         dictgen::InsensitiveStr::Ascii("inder"),
@@ -195291,12 +195291,12 @@ pub static WORD_CLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=5,
 };
 
-static WORD_CLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLU_CHILDREN),
+static WORD_CLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("ases"),
@@ -195340,12 +195340,12 @@ pub static WORD_CLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_CLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLS_CHILDREN),
+static WORD_CLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asified"),
         dictgen::InsensitiveStr::Ascii("oe"),
@@ -195365,23 +195365,23 @@ pub static WORD_CLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CLP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLP_CHILDREN),
+static WORD_CLP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("board")],
     values: &[&["clipboard"]],
     range: 5..=5,
 };
 
-static WORD_CLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLO_CHILDREN),
+static WORD_CLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("acks"),
@@ -195477,12 +195477,12 @@ pub static WORD_CLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_CLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLL_CHILDREN),
+static WORD_CLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLL_CHILDREN),
     value: Some(&["call"]),
 };
 
-pub static WORD_CLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oud"),
         dictgen::InsensitiveStr::Ascii("ouded"),
@@ -195500,12 +195500,12 @@ pub static WORD_CLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_CLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CLI_CHILDREN),
+static WORD_CLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CLI_CHILDREN),
     value: None,
 };
 
-static WORD_CLI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CLI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CLIA_NODE),
     Some(&WORD_CLIB_NODE),
     Some(&WORD_CLIC_NODE),
@@ -195534,12 +195534,12 @@ static WORD_CLI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CLIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIU_CHILDREN),
+static WORD_CLIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ents"),
@@ -195549,12 +195549,12 @@ pub static WORD_CLIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CLIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIT_CHILDREN),
+static WORD_CLIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iros"),
         dictgen::InsensitiveStr::Ascii("oridis"),
@@ -195576,12 +195576,12 @@ pub static WORD_CLIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CLIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIS_CHILDREN),
+static WORD_CLIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hay"),
         dictgen::InsensitiveStr::Ascii("hays"),
@@ -195592,12 +195592,12 @@ pub static WORD_CLIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CLIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIP_CHILDREN),
+static WORD_CLIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("baord"),
         dictgen::InsensitiveStr::Ascii("boad"),
@@ -195623,12 +195623,12 @@ pub static WORD_CLIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CLIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIN_CHILDREN),
+static WORD_CLIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cial"),
         dictgen::InsensitiveStr::Ascii("cially"),
@@ -195654,12 +195654,12 @@ pub static WORD_CLIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CLIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIM_CHILDREN),
+static WORD_CLIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ateers"),
         dictgen::InsensitiveStr::Ascii("atiser"),
@@ -195681,12 +195681,12 @@ pub static WORD_CLIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CLIK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIK_CHILDREN),
+static WORD_CLIK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIK_CHILDREN),
     value: Some(&["click"]),
 };
 
-pub static WORD_CLIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cbait"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -195695,12 +195695,12 @@ pub static WORD_CLIK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CLIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIF_CHILDREN),
+static WORD_CLIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fbanger"),
         dictgen::InsensitiveStr::Ascii("fhager"),
@@ -195718,12 +195718,12 @@ pub static WORD_CLIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=7,
 };
 
-static WORD_CLIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIE_CHILDREN),
+static WORD_CLIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("ns"),
@@ -195743,12 +195743,12 @@ pub static WORD_CLIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CLIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIC_CHILDREN),
+static WORD_CLIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kare"),
         dictgen::InsensitiveStr::Ascii("kbat"),
@@ -195766,12 +195766,12 @@ pub static WORD_CLIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_CLIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIB_CHILDREN),
+static WORD_CLIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oard"),
         dictgen::InsensitiveStr::Ascii("oards"),
@@ -195787,12 +195787,12 @@ pub static WORD_CLIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CLIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLIA_CHILDREN),
+static WORD_CLIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mtes"),
@@ -195802,23 +195802,23 @@ pub static WORD_CLIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CLH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLH_CHILDREN),
+static WORD_CLH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orine")],
     values: &[&["chlorine"]],
     range: 5..=5,
 };
 
-static WORD_CLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CLE_CHILDREN),
+static WORD_CLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CLE_CHILDREN),
     value: None,
 };
 
-static WORD_CLE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CLE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CLEA_NODE),
     None,
     Some(&WORD_CLEC_NODE),
@@ -195847,12 +195847,12 @@ static WORD_CLE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CLEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEV_CHILDREN),
+static WORD_CLEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elry"),
         dictgen::InsensitiveStr::Ascii("ely"),
@@ -195863,23 +195863,23 @@ pub static WORD_CLEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CLET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLET_CHILDREN),
+static WORD_CLET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLET_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ics")],
     values: &[&["celtics"]],
     range: 3..=3,
 };
 
-static WORD_CLES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLES_CHILDREN),
+static WORD_CLES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -195889,12 +195889,12 @@ pub static WORD_CLES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CLER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLER_CHILDREN),
+static WORD_CLER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLER_CHILDREN),
     value: Some(&["clear"]),
 };
 
-pub static WORD_CLER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("ification"),
@@ -195903,12 +195903,12 @@ pub static WORD_CLER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CLEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEN_CHILDREN),
+static WORD_CLEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEN_CHILDREN),
     value: Some(&["clan", "clean"]),
 };
 
-pub static WORD_CLEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ase"),
         dictgen::InsensitiveStr::Ascii("aser"),
@@ -195934,12 +195934,12 @@ pub static WORD_CLEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CLEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEI_CHILDREN),
+static WORD_CLEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("nts"),
@@ -195948,23 +195948,23 @@ pub static WORD_CLEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CLEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEF_CHILDREN),
+static WORD_CLEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("f")],
     values: &[&["clef"]],
     range: 1..=1,
 };
 
-static WORD_CLEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEE_CHILDREN),
+static WORD_CLEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("n"),
@@ -195988,23 +195988,23 @@ pub static WORD_CLEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CLEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEC_CHILDREN),
+static WORD_CLEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["check"]],
     range: 1..=1,
 };
 
-static WORD_CLEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLEA_CHILDREN),
+static WORD_CLEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLEA_CHILDREN),
     value: Some(&["clean"]),
 };
 
-pub static WORD_CLEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -196104,12 +196104,12 @@ pub static WORD_CLEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLC_CHILDREN),
+static WORD_CLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oksource"),
         dictgen::InsensitiveStr::Ascii("osed"),
@@ -196118,12 +196118,12 @@ pub static WORD_CLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_CLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CLA_CHILDREN),
+static WORD_CLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CLA_CHILDREN),
     value: None,
 };
 
-static WORD_CLA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CLA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CLAA_NODE),
     None,
     Some(&WORD_CLAC_NODE),
@@ -196152,12 +196152,12 @@ static WORD_CLA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CLAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAY_CHILDREN),
+static WORD_CLAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mer"),
         dictgen::InsensitiveStr::Ascii("moe"),
@@ -196166,12 +196166,12 @@ pub static WORD_CLAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_CLAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAU_CHILDREN),
+static WORD_CLAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("sens"),
@@ -196180,23 +196180,23 @@ pub static WORD_CLAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CLAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAT_CHILDREN),
+static WORD_CLAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ified")],
     values: &[&["clarified"]],
     range: 5..=5,
 };
 
-static WORD_CLAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAS_CHILDREN),
+static WORD_CLAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAS_CHILDREN),
     value: Some(&["class"]),
 };
 
-pub static WORD_CLAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -196290,12 +196290,12 @@ pub static WORD_CLAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_CLAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAR_CHILDREN),
+static WORD_CLAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avoyant"),
         dictgen::InsensitiveStr::Ascii("avoyantes"),
@@ -196327,12 +196327,12 @@ pub static WORD_CLAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CLAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAN_CHILDREN),
+static WORD_CLAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("and"),
         dictgen::InsensitiveStr::Ascii("nand"),
@@ -196341,12 +196341,12 @@ pub static WORD_CLAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CLAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAM_CHILDREN),
+static WORD_CLAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("mer"),
@@ -196362,12 +196362,12 @@ pub static WORD_CLAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CLAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAI_CHILDREN),
+static WORD_CLAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bre"),
         dictgen::InsensitiveStr::Ascii("bscale"),
@@ -196399,23 +196399,23 @@ pub static WORD_CLAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CLAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAG_CHILDREN),
+static WORD_CLAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ary")],
     values: &[&["calgary"]],
     range: 3..=3,
 };
 
-static WORD_CLAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAE_CHILDREN),
+static WORD_CLAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rer"),
@@ -196425,12 +196425,12 @@ pub static WORD_CLAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CLAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAC_CHILDREN),
+static WORD_CLAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ium"),
         dictgen::InsensitiveStr::Ascii("ulate"),
@@ -196452,23 +196452,23 @@ pub static WORD_CLAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CLAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CLAA_CHILDREN),
+static WORD_CLAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CLAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CLAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CLAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("es")],
     values: &[&["classes"]],
     range: 2..=2,
 };
 
-static WORD_CK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CK_CHILDREN),
+static WORD_CK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eck"),
         dictgen::InsensitiveStr::Ascii("ecksum"),
@@ -196478,12 +196478,12 @@ pub static WORD_CK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_CJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CJ_CHILDREN),
+static WORD_CJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("anged"),
@@ -196501,12 +196501,12 @@ pub static WORD_CJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_CI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CI_CHILDREN),
+static WORD_CI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CI_CHILDREN),
     value: None,
 };
 
-static WORD_CI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CIC_NODE),
@@ -196535,12 +196535,12 @@ static WORD_CI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIV_CHILDREN),
+static WORD_CIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alasation"),
         dictgen::InsensitiveStr::Ascii("alasations"),
@@ -196632,12 +196632,12 @@ pub static WORD_CIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=10,
 };
 
-static WORD_CIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIT_CHILDREN),
+static WORD_CIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icenship"),
         dictgen::InsensitiveStr::Ascii("isenship"),
@@ -196647,12 +196647,12 @@ pub static WORD_CIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=8,
 };
 
-static WORD_CIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CIR_CHILDREN),
+static WORD_CIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CIR_CHILDREN),
     value: None,
 };
 
-static WORD_CIR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CIR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CIRC_NODE),
@@ -196681,12 +196681,12 @@ static WORD_CIR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CIRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRU_CHILDREN),
+static WORD_CIRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("cit"),
@@ -196730,12 +196730,12 @@ pub static WORD_CIRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CIRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRT_CHILDREN),
+static WORD_CIRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cuit"),
         dictgen::InsensitiveStr::Ascii("icise"),
@@ -196745,23 +196745,23 @@ pub static WORD_CIRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_CIRS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRS_CHILDREN),
+static WORD_CIRS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("umstances")],
     values: &[&["circumstances"]],
     range: 9..=9,
 };
 
-static WORD_CIRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRR_CHILDREN),
+static WORD_CIRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ently"),
         dictgen::InsensitiveStr::Ascii("iculum"),
@@ -196771,23 +196771,23 @@ pub static WORD_CIRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_CIRQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRQ_CHILDREN),
+static WORD_CIRQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uit")],
     values: &[&["circuit"]],
     range: 3..=3,
 };
 
-static WORD_CIRL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRL_CHILDREN),
+static WORD_CIRL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -196805,12 +196805,12 @@ pub static WORD_CIRL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CIRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRI_CHILDREN),
+static WORD_CIRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cle"),
         dictgen::InsensitiveStr::Ascii("cles"),
@@ -196860,12 +196860,12 @@ pub static WORD_CIRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_CIRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CIRC_CHILDREN),
+static WORD_CIRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CIRC_CHILDREN),
     value: None,
 };
 
-static WORD_CIRC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CIRC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -196894,12 +196894,12 @@ static WORD_CIRC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CIRCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCU_CHILDREN),
+static WORD_CIRCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("altion"),
@@ -197025,12 +197025,12 @@ pub static WORD_CIRCU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_CIRCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCO_CHILDREN),
+static WORD_CIRCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mference"),
         dictgen::InsensitiveStr::Ascii("mstance"),
@@ -197050,12 +197050,12 @@ pub static WORD_CIRCO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_CIRCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCL_CHILDREN),
+static WORD_CIRCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebs"),
         dictgen::InsensitiveStr::Ascii("uar"),
@@ -197073,23 +197073,23 @@ pub static WORD_CIRCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CIRCK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCK_CHILDREN),
+static WORD_CIRCK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ets")],
     values: &[&["crickets"]],
     range: 3..=3,
 };
 
-static WORD_CIRCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCI_CHILDREN),
+static WORD_CIRCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mcised"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -197100,23 +197100,23 @@ pub static WORD_CIRCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CIRCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIRCE_CHILDREN),
+static WORD_CIRCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIRCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIRCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIRCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ls")],
     values: &[&["circles"]],
     range: 2..=2,
 };
 
-static WORD_CIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIP_CHILDREN),
+static WORD_CIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("board"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -197164,12 +197164,12 @@ pub static WORD_CIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_CIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIO_CHILDREN),
+static WORD_CIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntrol"),
         dictgen::InsensitiveStr::Ascii("tee"),
@@ -197179,12 +197179,12 @@ pub static WORD_CIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_CIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIN_CHILDREN),
+static WORD_CIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cinatti"),
         dictgen::InsensitiveStr::Ascii("cinnasti"),
@@ -197228,12 +197228,12 @@ pub static WORD_CIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=11,
 };
 
-static WORD_CIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIM_CHILDREN),
+static WORD_CIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etric"),
         dictgen::InsensitiveStr::Ascii("etrical"),
@@ -197293,12 +197293,12 @@ pub static WORD_CIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=12,
 };
 
-static WORD_CIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIL_CHILDREN),
+static WORD_CIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anto"),
         dictgen::InsensitiveStr::Ascii("dren"),
@@ -197344,12 +197344,12 @@ pub static WORD_CIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_CIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIH_CHILDREN),
+static WORD_CIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("pher"),
@@ -197359,12 +197359,12 @@ pub static WORD_CIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_CIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIG_CHILDREN),
+static WORD_CIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arattes"),
         dictgen::InsensitiveStr::Ascii("arete"),
@@ -197410,12 +197410,12 @@ pub static WORD_CIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_CIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIE_CHILDREN),
+static WORD_CIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ling"),
         dictgen::InsensitiveStr::Ascii("lings"),
@@ -197426,12 +197426,12 @@ pub static WORD_CIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CIC_CHILDREN),
+static WORD_CIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("k"),
         dictgen::InsensitiveStr::Ascii("rle"),
@@ -197453,12 +197453,12 @@ pub static WORD_CIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_CH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CH_CHILDREN),
+static WORD_CH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CH_CHILDREN),
     value: None,
 };
 
-static WORD_CH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHA_NODE),
     None,
     Some(&WORD_CHC_NODE),
@@ -197487,12 +197487,12 @@ static WORD_CH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHU_CHILDREN),
+static WORD_CHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bks"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -197530,23 +197530,23 @@ pub static WORD_CHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHT_CHILDREN),
+static WORD_CHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ulhu")],
     values: &[&["cthulhu"]],
     range: 4..=4,
 };
 
-static WORD_CHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHR_CHILDREN),
+static WORD_CHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -197680,12 +197680,12 @@ pub static WORD_CHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_CHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHO_CHILDREN),
+static WORD_CHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atic"),
         dictgen::InsensitiveStr::Ascii("calates"),
@@ -197809,12 +197809,12 @@ pub static WORD_CHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_CHN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHN_CHILDREN),
+static WORD_CHN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("age"),
@@ -197856,23 +197856,23 @@ pub static WORD_CHN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_CHM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHM_CHILDREN),
+static WORD_CHM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("abers")],
     values: &[&["chambers"]],
     range: 5..=5,
 };
 
-static WORD_CHL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHL_CHILDREN),
+static WORD_CHL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esea"),
         dictgen::InsensitiveStr::Ascii("id"),
@@ -197898,23 +197898,23 @@ pub static WORD_CHL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_CHK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHK_CHILDREN),
+static WORD_CHK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["checked"]],
     range: 2..=2,
 };
 
-static WORD_CHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHI_CHILDREN),
+static WORD_CHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHI_CHILDREN),
     value: None,
 };
 
-static WORD_CHI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHIA_NODE),
     None,
     None,
@@ -197943,12 +197943,12 @@ static WORD_CHI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHIZ_NODE),
 ];
 
-static WORD_CHIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIZ_CHILDREN),
+static WORD_CHIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ell"),
         dictgen::InsensitiveStr::Ascii("elle"),
@@ -198010,12 +198010,12 @@ pub static WORD_CHIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CHIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIV_CHILDREN),
+static WORD_CHIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aly"),
         dictgen::InsensitiveStr::Ascii("arly"),
@@ -198025,12 +198025,12 @@ pub static WORD_CHIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CHIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIU_CHILDREN),
+static WORD_CHIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hahua"),
         dictgen::InsensitiveStr::Ascii("ldren"),
@@ -198039,12 +198039,12 @@ pub static WORD_CHIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_CHIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIS_CHILDREN),
+static WORD_CHIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ell"),
         dictgen::InsensitiveStr::Ascii("elle"),
@@ -198076,12 +198076,12 @@ pub static WORD_CHIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIR_CHILDREN),
+static WORD_CHIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stian"),
         dictgen::InsensitiveStr::Ascii("stianity"),
@@ -198097,12 +198097,12 @@ pub static WORD_CHIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_CHIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIP_CHILDREN),
+static WORD_CHIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -198134,12 +198134,12 @@ pub static WORD_CHIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_CHIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIO_CHILDREN),
+static WORD_CHIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("p"),
@@ -198148,12 +198148,12 @@ pub static WORD_CHIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CHIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIN_CHILDREN),
+static WORD_CHIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ees"),
         dictgen::InsensitiveStr::Ascii("eese"),
@@ -198171,12 +198171,12 @@ pub static WORD_CHIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CHIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIM_CHILDREN),
+static WORD_CHIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eny"),
         dictgen::InsensitiveStr::Ascii("menies"),
@@ -198186,12 +198186,12 @@ pub static WORD_CHIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIL_CHILDREN),
+static WORD_CHIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dbird"),
         dictgen::InsensitiveStr::Ascii("dbrith"),
@@ -198243,12 +198243,12 @@ pub static WORD_CHIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CHIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIH_CHILDREN),
+static WORD_CHIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("auhua"),
         dictgen::InsensitiveStr::Ascii("uaha"),
@@ -198266,23 +198266,23 @@ pub static WORD_CHIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_CHIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIE_CHILDREN),
+static WORD_CHIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nse")],
     values: &[&["chinese"]],
     range: 3..=3,
 };
 
-static WORD_CHID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHID_CHILDREN),
+static WORD_CHID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHID_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lbirth"),
         dictgen::InsensitiveStr::Ascii("lfree"),
@@ -198302,34 +198302,34 @@ pub static WORD_CHID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHIA_CHILDREN),
+static WORD_CHIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nsaw")],
     values: &[&["chainsaw"]],
     range: 4..=4,
 };
 
-static WORD_CHH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHH_CHILDREN),
+static WORD_CHH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ange")],
     values: &[&["change"]],
     range: 4..=4,
 };
 
-static WORD_CHG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHG_CHILDREN),
+static WORD_CHG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ange"),
         dictgen::InsensitiveStr::Ascii("anged"),
@@ -198340,12 +198340,12 @@ pub static WORD_CHG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_CHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHE_CHILDREN),
+static WORD_CHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHE_CHILDREN),
     value: None,
 };
 
-static WORD_CHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHEA_NODE),
     None,
     Some(&WORD_CHEC_NODE),
@@ -198374,12 +198374,12 @@ static WORD_CHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHES_CHILDREN),
+static WORD_CHES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cksums"),
         dictgen::InsensitiveStr::Ascii("lea"),
@@ -198388,12 +198388,12 @@ pub static WORD_CHES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHER_CHILDREN),
+static WORD_CHER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHER_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ching"),
@@ -198427,12 +198427,12 @@ pub static WORD_CHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEN_CHILDREN),
+static WORD_CHEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ged"),
         dictgen::InsensitiveStr::Ascii("nel"),
@@ -198441,12 +198441,12 @@ pub static WORD_CHEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_CHEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEM_CHILDREN),
+static WORD_CHEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cial"),
         dictgen::InsensitiveStr::Ascii("cially"),
@@ -198466,12 +198466,12 @@ pub static WORD_CHEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CHEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEL_CHILDREN),
+static WORD_CHEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lo"),
         dictgen::InsensitiveStr::Ascii("sae"),
@@ -198480,12 +198480,12 @@ pub static WORD_CHEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CHEK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEK_CHILDREN),
+static WORD_CHEK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEK_CHILDREN),
     value: Some(&["check"]),
 };
 
-pub static WORD_CHEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cer"),
@@ -198521,12 +198521,12 @@ pub static WORD_CHEK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CHEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEI_CHILDREN),
+static WORD_CHEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("f"),
         dictgen::InsensitiveStr::Ascii("fs"),
@@ -198535,12 +198535,12 @@ pub static WORD_CHEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CHEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEE_CHILDREN),
+static WORD_CHEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ck"),
         dictgen::InsensitiveStr::Ascii("ots"),
@@ -198608,23 +198608,23 @@ pub static WORD_CHEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CHED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHED_CHILDREN),
+static WORD_CHED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uling")],
     values: &[&["scheduling"]],
     range: 5..=5,
 };
 
-static WORD_CHEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEC_CHILDREN),
+static WORD_CHEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEC_CHILDREN),
     value: Some(&["check"]),
 };
 
-pub static WORD_CHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("box"),
         dictgen::InsensitiveStr::Ascii("boxes"),
@@ -198738,12 +198738,12 @@ pub static WORD_CHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CHEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHEA_CHILDREN),
+static WORD_CHEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("peast"),
         dictgen::InsensitiveStr::Ascii("tta"),
@@ -198752,12 +198752,12 @@ pub static WORD_CHEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CHC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHC_CHILDREN),
+static WORD_CHC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ek"),
         dictgen::InsensitiveStr::Ascii("eked"),
@@ -198779,12 +198779,12 @@ pub static WORD_CHC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_CHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHA_CHILDREN),
+static WORD_CHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHA_CHILDREN),
     value: None,
 };
 
-static WORD_CHA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHAA_NODE),
     None,
     Some(&WORD_CHAC_NODE),
@@ -198813,23 +198813,23 @@ static WORD_CHA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHAW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAW_CHILDREN),
+static WORD_CHAW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAW_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["chalk"]],
     range: 1..=1,
 };
 
-static WORD_CHAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAT_CHILDREN),
+static WORD_CHAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -198873,12 +198873,12 @@ pub static WORD_CHAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CHAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAS_CHILDREN),
+static WORD_CHAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iers"),
         dictgen::InsensitiveStr::Ascii("im"),
@@ -198912,12 +198912,12 @@ pub static WORD_CHAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CHAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHAR_CHILDREN),
+static WORD_CHAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHAR_CHILDREN),
     value: None,
 };
 
-static WORD_CHAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHARA_NODE),
     None,
     Some(&WORD_CHARC_NODE),
@@ -198946,12 +198946,12 @@ static WORD_CHAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHART_CHILDREN),
+static WORD_CHART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHART_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("roose"),
@@ -198960,12 +198960,12 @@ pub static WORD_CHART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_CHARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARS_CHILDREN),
+static WORD_CHARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ima"),
         dictgen::InsensitiveStr::Ascii("imatic"),
@@ -198974,34 +198974,34 @@ pub static WORD_CHARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARO_CHILDREN),
+static WORD_CHARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cal")],
     values: &[&["charcoal"]],
     range: 3..=3,
 };
 
-static WORD_CHARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARM_CHILDREN),
+static WORD_CHARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("isa")],
     values: &[&["charisma"]],
     range: 3..=3,
 };
 
-static WORD_CHARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARI_CHILDREN),
+static WORD_CHARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARI_CHILDREN),
     value: Some(&["chair"]),
 };
 
-pub static WORD_CHARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cter"),
         dictgen::InsensitiveStr::Ascii("cterization"),
@@ -199041,12 +199041,12 @@ pub static WORD_CHARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_CHARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARG_CHILDREN),
+static WORD_CHARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ehr"),
         dictgen::InsensitiveStr::Ascii("eur"),
@@ -199056,12 +199056,12 @@ pub static WORD_CHARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_CHARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARE_CHILDREN),
+static WORD_CHARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cter"),
         dictgen::InsensitiveStr::Ascii("cteristic"),
@@ -199081,12 +199081,12 @@ pub static WORD_CHARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=11,
 };
 
-static WORD_CHARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARC_CHILDREN),
+static WORD_CHARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aol"),
         dictgen::InsensitiveStr::Ascii("ater"),
@@ -199114,12 +199114,12 @@ pub static WORD_CHARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CHARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHARA_CHILDREN),
+static WORD_CHARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHARA_CHILDREN),
     value: None,
 };
 
-static WORD_CHARA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHARA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_CHARAC_NODE),
@@ -199148,12 +199148,12 @@ static WORD_CHARA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHARAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARAT_CHILDREN),
+static WORD_CHARAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("cer"),
@@ -199177,12 +199177,12 @@ pub static WORD_CHARAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=6,
 };
 
-static WORD_CHARAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARAS_CHILDREN),
+static WORD_CHARAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARAS_CHILDREN),
     value: Some(&["chars"]),
 };
 
-pub static WORD_CHARAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cter"),
         dictgen::InsensitiveStr::Ascii("cters"),
@@ -199202,12 +199202,12 @@ pub static WORD_CHARAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=8,
 };
 
-static WORD_CHARAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARAR_CHILDREN),
+static WORD_CHARAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -199223,12 +199223,12 @@ pub static WORD_CHARAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=6,
 };
 
-static WORD_CHARAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARAK_CHILDREN),
+static WORD_CHARAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ter"),
         dictgen::InsensitiveStr::Ascii("ters"),
@@ -199237,12 +199237,12 @@ pub static WORD_CHARAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=4,
 };
 
-static WORD_CHARAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHARAC_CHILDREN),
+static WORD_CHARAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHARAC_CHILDREN),
     value: None,
 };
 
-static WORD_CHARAC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHARAC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHARACA_NODE),
     None,
     None,
@@ -199271,23 +199271,23 @@ static WORD_CHARAC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHARACY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACY_CHILDREN),
+static WORD_CHARACY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ers")],
     values: &[&["characters"]],
     range: 3..=3,
 };
 
-static WORD_CHARACT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHARACT_CHILDREN),
+static WORD_CHARACT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHARACT_CHILDREN),
     value: None,
 };
 
-static WORD_CHARACT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHARACT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHARACTA_NODE),
     None,
     None,
@@ -199316,34 +199316,34 @@ static WORD_CHARACT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHARACTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTU_CHILDREN),
+static WORD_CHARACTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("re")],
     values: &[&["character"]],
     range: 2..=2,
 };
 
-static WORD_CHARACTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTS_CHILDREN),
+static WORD_CHARACTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTS_CHILDREN),
     value: Some(&["characters"]),
 };
 
-pub static WORD_CHARACTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_CHARACTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTR_CHILDREN),
+static WORD_CHARACTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTR_CHILDREN),
     value: Some(&["character"]),
 };
 
-pub static WORD_CHARACTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("istic"),
@@ -199361,12 +199361,12 @@ pub static WORD_CHARACTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=9,
 };
 
-static WORD_CHARACTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTO_CHILDREN),
+static WORD_CHARACTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ristics"),
@@ -199376,12 +199376,12 @@ pub static WORD_CHARACTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=7,
 };
 
-static WORD_CHARACTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTI_CHILDREN),
+static WORD_CHARACTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ristic"),
         dictgen::InsensitiveStr::Ascii("ristically"),
@@ -199395,23 +199395,23 @@ pub static WORD_CHARACTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 6..=10,
 };
 
-static WORD_CHARACTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTH_CHILDREN),
+static WORD_CHARACTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["character"]],
     range: 2..=2,
 };
 
-static WORD_CHARACTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTE_CHILDREN),
+static WORD_CHARACTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTE_CHILDREN),
     value: Some(&["character"]),
 };
 
-pub static WORD_CHARACTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -199533,12 +199533,12 @@ pub static WORD_CHARACTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=11,
 };
 
-static WORD_CHARACTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTA_CHILDREN),
+static WORD_CHARACTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ristic"),
@@ -199560,23 +199560,23 @@ pub static WORD_CHARACTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTa
     range: 1..=8,
 };
 
-static WORD_CHARACS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACS_CHILDREN),
+static WORD_CHARACS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tyle")],
     values: &[&["charstyle"]],
     range: 4..=4,
 };
 
-static WORD_CHARACH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACH_CHILDREN),
+static WORD_CHARACH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -199592,23 +199592,23 @@ pub static WORD_CHARACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_CHARACG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACG_CHILDREN),
+static WORD_CHARACG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["character"]],
     range: 3..=3,
 };
 
-static WORD_CHARACE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACE_CHILDREN),
+static WORD_CHARACE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rs"),
@@ -199628,12 +199628,12 @@ pub static WORD_CHARACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 1..=4,
 };
 
-static WORD_CHARACA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHARACA_CHILDREN),
+static WORD_CHARACA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHARACA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHARACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHARACA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ter"),
         dictgen::InsensitiveStr::Ascii("ters"),
@@ -199642,23 +199642,23 @@ pub static WORD_CHARACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=4,
 };
 
-static WORD_CHAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAP_CHILDREN),
+static WORD_CHAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["chapter"]],
     range: 2..=2,
 };
 
-static WORD_CHAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CHAN_CHILDREN),
+static WORD_CHAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CHAN_CHILDREN),
     value: None,
 };
 
-static WORD_CHAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CHAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CHANA_NODE),
     None,
     Some(&WORD_CHANC_NODE),
@@ -199687,12 +199687,12 @@ static WORD_CHAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CHANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANS_CHILDREN),
+static WORD_CHANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ellor"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -199701,12 +199701,12 @@ pub static WORD_CHANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHANP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANP_CHILDREN),
+static WORD_CHANP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ionship"),
         dictgen::InsensitiveStr::Ascii("ionships"),
@@ -199715,12 +199715,12 @@ pub static WORD_CHANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_CHANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANN_CHILDREN),
+static WORD_CHANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ael"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -199756,12 +199756,12 @@ pub static WORD_CHANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CHANL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANL_CHILDREN),
+static WORD_CHANL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("der"),
         dictgen::InsensitiveStr::Ascii("lenge"),
@@ -199771,12 +199771,12 @@ pub static WORD_CHANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CHANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANI_CHILDREN),
+static WORD_CHANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ned"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -199792,12 +199792,12 @@ pub static WORD_CHANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANG_CHILDREN),
+static WORD_CHANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -199839,12 +199839,12 @@ pub static WORD_CHANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CHANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANE_CHILDREN),
+static WORD_CHANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANE_CHILDREN),
     value: Some(&["change", "chain"]),
 };
 
-pub static WORD_CHANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -199864,12 +199864,12 @@ pub static WORD_CHANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_CHAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAND_CHILDREN),
+static WORD_CHAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aleer"),
         dictgen::InsensitiveStr::Ascii("aleers"),
@@ -199891,12 +199891,12 @@ pub static WORD_CHAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CHANC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANC_CHILDREN),
+static WORD_CHANC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -199918,12 +199918,12 @@ pub static WORD_CHANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CHANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHANA_CHILDREN),
+static WORD_CHANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("ged"),
@@ -199941,12 +199941,12 @@ pub static WORD_CHANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_CHAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAM_CHILDREN),
+static WORD_CHAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bear"),
         dictgen::InsensitiveStr::Ascii("bre"),
@@ -200000,12 +200000,12 @@ pub static WORD_CHAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CHAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAL_CHILDREN),
+static WORD_CHAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enges"),
         dictgen::InsensitiveStr::Ascii("enging"),
@@ -200061,12 +200061,12 @@ pub static WORD_CHAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CHAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAI_CHILDREN),
+static WORD_CHAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -200077,12 +200077,12 @@ pub static WORD_CHAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CHAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAH_CHILDREN),
+static WORD_CHAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ged"),
         dictgen::InsensitiveStr::Ascii("ging"),
@@ -200091,12 +200091,12 @@ pub static WORD_CHAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CHAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAG_CHILDREN),
+static WORD_CHAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -200118,12 +200118,12 @@ pub static WORD_CHAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CHAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAE_CHILDREN),
+static WORD_CHAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ck"),
         dictgen::InsensitiveStr::Ascii("cked"),
@@ -200141,12 +200141,12 @@ pub static WORD_CHAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_CHAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAC_CHILDREN),
+static WORD_CHAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -200168,12 +200168,12 @@ pub static WORD_CHAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CHAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CHAA_CHILDREN),
+static WORD_CHAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CHAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CHAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CHAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rcter"),
         dictgen::InsensitiveStr::Ascii("rcters"),
@@ -200183,23 +200183,23 @@ pub static WORD_CHAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CG_CHILDREN),
+static WORD_CG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ywin")],
     values: &[&["cygwin"]],
     range: 4..=4,
 };
 
-static WORD_CE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CE_CHILDREN),
+static WORD_CE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CE_CHILDREN),
     value: None,
 };
 
-static WORD_CE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CEA_NODE),
     None,
     Some(&WORD_CEC_NODE),
@@ -200228,12 +200228,12 @@ static WORD_CE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CET_CHILDREN),
+static WORD_CET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CET_CHILDREN),
     value: None,
 };
 
-pub static WORD_CET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainly"),
@@ -200253,12 +200253,12 @@ pub static WORD_CET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_CES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CES_CHILDREN),
+static WORD_CES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CES_CHILDREN),
     value: None,
 };
 
-pub static WORD_CES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sationalism"),
         dictgen::InsensitiveStr::Ascii("sationalist"),
@@ -200274,12 +200274,12 @@ pub static WORD_CES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_CER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CER_CHILDREN),
+static WORD_CER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CER_CHILDREN),
     value: None,
 };
 
-static WORD_CER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CER_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CERA_NODE),
     Some(&WORD_CERB_NODE),
     Some(&WORD_CERC_NODE),
@@ -200308,23 +200308,23 @@ static WORD_CER_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CERV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERV_CHILDREN),
+static WORD_CERV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ial")],
     values: &[&["cervical", "servile", "serval"]],
     range: 3..=3,
 };
 
-static WORD_CERT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CERT_CHILDREN),
+static WORD_CERT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CERT_CHILDREN),
     value: None,
 };
 
-static WORD_CERT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CERT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CERTA_NODE),
     None,
     None,
@@ -200353,12 +200353,12 @@ static WORD_CERT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CERTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERTI_CHILDREN),
+static WORD_CERTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERTI_CHILDREN),
     value: Some(&["certificate", "certify"]),
 };
 
-pub static WORD_CERTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ainly"),
@@ -200484,12 +200484,12 @@ pub static WORD_CERTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_CERTF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERTF_CHILDREN),
+static WORD_CERTF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERTF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERTF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icate"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -200521,23 +200521,23 @@ pub static WORD_CERTF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CERTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERTE_CHILDREN),
+static WORD_CERTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rn")],
     values: &[&["certain"]],
     range: 2..=2,
 };
 
-static WORD_CERTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERTA_CHILDREN),
+static WORD_CERTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ily"),
         dictgen::InsensitiveStr::Ascii("incy"),
@@ -200569,12 +200569,12 @@ pub static WORD_CERTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_CERR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERR_CHILDREN),
+static WORD_CERR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebral"),
         dictgen::InsensitiveStr::Ascii("ebrally"),
@@ -200583,23 +200583,23 @@ pub static WORD_CERR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CERO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERO_CHILDREN),
+static WORD_CERO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mony")],
     values: &[&["ceremony"]],
     range: 4..=4,
 };
 
-static WORD_CERN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERN_CHILDREN),
+static WORD_CERN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omial"),
         dictgen::InsensitiveStr::Ascii("omially"),
@@ -200615,12 +200615,12 @@ pub static WORD_CERN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CERM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERM_CHILDREN),
+static WORD_CERM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aic"),
         dictgen::InsensitiveStr::Ascii("onial"),
@@ -200638,12 +200638,12 @@ pub static WORD_CERM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CERI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERI_CHILDREN),
+static WORD_CERI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ficate"),
         dictgen::InsensitiveStr::Ascii("fication"),
@@ -200685,12 +200685,12 @@ pub static WORD_CERI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CERE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERE_CHILDREN),
+static WORD_CERE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("brawl"),
@@ -200710,12 +200710,12 @@ pub static WORD_CERE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_CERC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERC_CHILDREN),
+static WORD_CERC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omstance"),
         dictgen::InsensitiveStr::Ascii("omstances"),
@@ -200739,12 +200739,12 @@ pub static WORD_CERC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=10,
 };
 
-static WORD_CERB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERB_CHILDREN),
+static WORD_CERB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eral"),
         dictgen::InsensitiveStr::Ascii("reus"),
@@ -200754,12 +200754,12 @@ pub static WORD_CERB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_CERA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CERA_CHILDREN),
+static WORD_CERA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CERA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CERA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("inly"),
@@ -200779,12 +200779,12 @@ pub static WORD_CERA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_CEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEN_CHILDREN),
+static WORD_CEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ario"),
         dictgen::InsensitiveStr::Ascii("arios"),
@@ -200886,12 +200886,12 @@ pub static WORD_CEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_CEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEM_CHILDREN),
+static WORD_CEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entary"),
         dictgen::InsensitiveStr::Ascii("etarey"),
@@ -200902,12 +200902,12 @@ pub static WORD_CEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_CEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEL_CHILDREN),
+static WORD_CEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -201009,12 +201009,12 @@ pub static WORD_CEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_CEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEH_CHILDREN),
+static WORD_CEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ck"),
         dictgen::InsensitiveStr::Ascii("cked"),
@@ -201034,12 +201034,12 @@ pub static WORD_CEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CED_CHILDREN),
+static WORD_CED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CED_CHILDREN),
     value: None,
 };
 
-pub static WORD_CED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ential"),
         dictgen::InsensitiveStr::Ascii("entials"),
@@ -201048,12 +201048,12 @@ pub static WORD_CED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_CEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEC_CHILDREN),
+static WORD_CEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("k"),
         dictgen::InsensitiveStr::Ascii("ked"),
@@ -201071,12 +201071,12 @@ pub static WORD_CEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_CEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CEA_CHILDREN),
+static WORD_CEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rtype"),
         dictgen::InsensitiveStr::Ascii("sar"),
@@ -201108,23 +201108,23 @@ pub static WORD_CEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CD_CHILDREN),
+static WORD_CD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ecompress")],
     values: &[&["decompress"]],
     range: 9..=9,
 };
 
-static WORD_CC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CC_CHILDREN),
+static WORD_CC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahe"),
         dictgen::InsensitiveStr::Ascii("ale"),
@@ -201174,12 +201174,12 @@ pub static WORD_CC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_CA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CA_CHILDREN),
+static WORD_CA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CA_CHILDREN),
     value: None,
 };
 
-static WORD_CA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CAA_NODE),
     Some(&WORD_CAB_NODE),
     Some(&WORD_CAC_NODE),
@@ -201208,12 +201208,12 @@ static WORD_CA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAV_CHILDREN),
+static WORD_CAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aet"),
         dictgen::InsensitiveStr::Ascii("aets"),
@@ -201233,12 +201233,12 @@ pub static WORD_CAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_CAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAU_CHILDREN),
+static WORD_CAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caisan"),
         dictgen::InsensitiveStr::Ascii("casain"),
@@ -201292,12 +201292,12 @@ pub static WORD_CAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_CAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAT_CHILDREN),
+static WORD_CAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAT_CHILDREN),
     value: None,
 };
 
-static WORD_CAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CATA_NODE),
     None,
     Some(&WORD_CATC_NODE),
@@ -201326,23 +201326,23 @@ static WORD_CAT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATU_CHILDREN),
+static WORD_CATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("re")],
     values: &[&["capture"]],
     range: 2..=2,
 };
 
-static WORD_CATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATT_CHILDREN),
+static WORD_CATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erpilar"),
         dictgen::InsensitiveStr::Ascii("erpilars"),
@@ -201360,34 +201360,34 @@ pub static WORD_CATT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_CATS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATS_CHILDREN),
+static WORD_CATS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("trophe")],
     values: &[&["catastrophe"]],
     range: 6..=6,
 };
 
-static WORD_CATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATR_CHILDREN),
+static WORD_CATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("idge")],
     values: &[&["cartridge"]],
     range: 4..=4,
 };
 
-static WORD_CATP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATP_CHILDREN),
+static WORD_CATP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ture"),
         dictgen::InsensitiveStr::Ascii("ure"),
@@ -201398,12 +201398,12 @@ pub static WORD_CATP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CATO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATO_CHILDREN),
+static WORD_CATO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gerized"),
         dictgen::InsensitiveStr::Ascii("gory"),
@@ -201423,12 +201423,12 @@ pub static WORD_CATO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_CATL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATL_CHILDREN),
+static WORD_CATL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayst"),
         dictgen::InsensitiveStr::Ascii("oag"),
@@ -201439,12 +201439,12 @@ pub static WORD_CATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATI_CHILDREN),
+static WORD_CATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gorically"),
         dictgen::InsensitiveStr::Ascii("strophic"),
@@ -201454,12 +201454,12 @@ pub static WORD_CATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_CATH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATH_CHILDREN),
+static WORD_CATH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("deral"),
         dictgen::InsensitiveStr::Ascii("erdal"),
@@ -201501,12 +201501,12 @@ pub static WORD_CATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CATG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATG_CHILDREN),
+static WORD_CATG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eory"),
         dictgen::InsensitiveStr::Ascii("orical"),
@@ -201524,12 +201524,12 @@ pub static WORD_CATG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATE_CHILDREN),
+static WORD_CATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gogical"),
         dictgen::InsensitiveStr::Ascii("gogically"),
@@ -201599,12 +201599,12 @@ pub static WORD_CATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATC_CHILDREN),
+static WORD_CATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("hed"),
@@ -201622,12 +201622,12 @@ pub static WORD_CATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_CATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CATA_CHILDREN),
+static WORD_CATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alogue"),
         dictgen::InsensitiveStr::Ascii("clism"),
@@ -201727,12 +201727,12 @@ pub static WORD_CATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_CAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAS_CHILDREN),
+static WORD_CAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arole"),
         dictgen::InsensitiveStr::Ascii("aroles"),
@@ -201834,12 +201834,12 @@ pub static WORD_CAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_CAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAR_CHILDREN),
+static WORD_CAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAR_CHILDREN),
     value: None,
 };
 
-static WORD_CAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CARA_NODE),
     Some(&WORD_CARB_NODE),
     Some(&WORD_CARC_NODE),
@@ -201868,12 +201868,12 @@ static WORD_CAR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CARY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARY_CHILDREN),
+static WORD_CARY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ons"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -201882,23 +201882,23 @@ pub static WORD_CARY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CARV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARV_CHILDREN),
+static WORD_CARV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inal")],
     values: &[&["carnival"]],
     range: 4..=4,
 };
 
-static WORD_CART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CART_CHILDREN),
+static WORD_CART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CART_CHILDREN),
     value: None,
 };
 
-pub static WORD_CART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("dridge"),
@@ -201968,12 +201968,12 @@ pub static WORD_CART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARR_CHILDREN),
+static WORD_CARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ages"),
@@ -202025,12 +202025,12 @@ pub static WORD_CARR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CARP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARP_CHILDREN),
+static WORD_CARP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etner"),
         dictgen::InsensitiveStr::Ascii("tener"),
@@ -202039,12 +202039,12 @@ pub static WORD_CARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=5,
 };
 
-static WORD_CARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARO_CHILDREN),
+static WORD_CARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lan"),
         dictgen::InsensitiveStr::Ascii("linia"),
@@ -202066,12 +202066,12 @@ pub static WORD_CARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CARN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARN_CHILDREN),
+static WORD_CARN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARN_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agie"),
         dictgen::InsensitiveStr::Ascii("avor"),
@@ -202107,12 +202107,12 @@ pub static WORD_CARN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARM_CHILDREN),
+static WORD_CARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alite"),
         dictgen::InsensitiveStr::Ascii("onial"),
@@ -202132,23 +202132,23 @@ pub static WORD_CARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARL_CHILDREN),
+static WORD_CARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oina")],
     values: &[&["carolina"]],
     range: 4..=4,
 };
 
-static WORD_CARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARI_CHILDREN),
+static WORD_CARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acture"),
         dictgen::InsensitiveStr::Ascii("actures"),
@@ -202214,12 +202214,12 @@ pub static WORD_CARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_CARF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARF_CHILDREN),
+static WORD_CARF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ull"),
         dictgen::InsensitiveStr::Ascii("ully"),
@@ -202228,12 +202228,12 @@ pub static WORD_CARF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARE_CHILDREN),
+static WORD_CARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("flly"),
         dictgen::InsensitiveStr::Ascii("full"),
@@ -202251,12 +202251,12 @@ pub static WORD_CARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARD_CHILDREN),
+static WORD_CARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aic"),
         dictgen::InsensitiveStr::Ascii("baord"),
@@ -202298,12 +202298,12 @@ pub static WORD_CARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=13,
 };
 
-static WORD_CARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARC_CHILDREN),
+static WORD_CARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("as"),
         dictgen::InsensitiveStr::Ascii("iature"),
@@ -202319,12 +202319,12 @@ pub static WORD_CARC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_CARB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARB_CHILDREN),
+static WORD_CARB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ien"),
         dictgen::InsensitiveStr::Ascii("ohdyrates"),
@@ -202348,12 +202348,12 @@ pub static WORD_CARB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_CARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CARA_CHILDREN),
+static WORD_CARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("boo"),
         dictgen::InsensitiveStr::Ascii("boos"),
@@ -202385,12 +202385,12 @@ pub static WORD_CARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAP_CHILDREN),
+static WORD_CAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAP_CHILDREN),
     value: None,
 };
 
-static WORD_CAP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CAPA_NODE),
     Some(&WORD_CAPB_NODE),
     Some(&WORD_CAPC_NODE),
@@ -202419,12 +202419,12 @@ static WORD_CAP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CAPU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPU_CHILDREN),
+static WORD_CAPU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sle"),
         dictgen::InsensitiveStr::Ascii("sles"),
@@ -202444,12 +202444,12 @@ pub static WORD_CAPU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CAPT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPT_CHILDREN),
+static WORD_CAPT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ainers"),
@@ -202505,12 +202505,12 @@ pub static WORD_CAPT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_CAPS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPS_CHILDREN),
+static WORD_CAPS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uels"),
         dictgen::InsensitiveStr::Ascii("ulers"),
@@ -202530,45 +202530,45 @@ pub static WORD_CAPS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CAPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPR_CHILDREN),
+static WORD_CAPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enter")],
     values: &[&["carpenter"]],
     range: 5..=5,
 };
 
-static WORD_CAPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPP_CHILDREN),
+static WORD_CAPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("able")],
     values: &[&["capable"]],
     range: 4..=4,
 };
 
-static WORD_CAPM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPM_CHILDREN),
+static WORD_CAPM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("bell")],
     values: &[&["campbell"]],
     range: 4..=4,
 };
 
-static WORD_CAPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPI_CHILDREN),
+static WORD_CAPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alized"),
         dictgen::InsensitiveStr::Ascii("bilities"),
@@ -202654,12 +202654,12 @@ pub static WORD_CAPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_CAPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPE_CHILDREN),
+static WORD_CAPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("la"),
         dictgen::InsensitiveStr::Ascii("rbility"),
@@ -202668,12 +202668,12 @@ pub static WORD_CAPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_CAPC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPC_CHILDREN),
+static WORD_CAPC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acity"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -202682,12 +202682,12 @@ pub static WORD_CAPC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CAPB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPB_CHILDREN),
+static WORD_CAPB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("ale"),
@@ -202696,12 +202696,12 @@ pub static WORD_CAPB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_CAPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAPA_CHILDREN),
+static WORD_CAPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acity"),
         dictgen::InsensitiveStr::Ascii("bable"),
@@ -202797,12 +202797,12 @@ pub static WORD_CAPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_CAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAO_CHILDREN),
+static WORD_CAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("st"),
         dictgen::InsensitiveStr::Ascii("uld"),
@@ -202811,12 +202811,12 @@ pub static WORD_CAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_CAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAN_CHILDREN),
+static WORD_CAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAN_CHILDREN),
     value: None,
 };
 
-static WORD_CAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CANA_NODE),
     None,
     Some(&WORD_CANC_NODE),
@@ -202845,34 +202845,34 @@ static WORD_CAN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CANY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANY_CHILDREN),
+static WORD_CANY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["canaille"]],
     range: 1..=1,
 };
 
-static WORD_CANV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANV_CHILDREN),
+static WORD_CANV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANV_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ase")],
     values: &[&["canvas"]],
     range: 3..=3,
 };
 
-static WORD_CANT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANT_CHILDREN),
+static WORD_CANT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -202900,34 +202900,34 @@ pub static WORD_CANT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_CANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANS_CHILDREN),
+static WORD_CANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iter")],
     values: &[&["canister"]],
     range: 4..=4,
 };
 
-static WORD_CANR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANR_CHILDREN),
+static WORD_CANR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["carnage"]],
     range: 3..=3,
 };
 
-static WORD_CANO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANO_CHILDREN),
+static WORD_CANO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cical"),
         dictgen::InsensitiveStr::Ascii("ical"),
@@ -202963,12 +202963,12 @@ pub static WORD_CANO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_CANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANN_CHILDREN),
+static WORD_CANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANN_CHILDREN),
     value: Some(&["can"]),
 };
 
-pub static WORD_CANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abil"),
         dictgen::InsensitiveStr::Ascii("abile"),
@@ -203056,12 +203056,12 @@ pub static WORD_CANN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=13,
 };
 
-static WORD_CANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANI_CHILDREN),
+static WORD_CANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("date"),
         dictgen::InsensitiveStr::Ascii("dates"),
@@ -203072,12 +203072,12 @@ pub static WORD_CANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_CANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANG_CHILDREN),
+static WORD_CANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -203088,12 +203088,12 @@ pub static WORD_CANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_CANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANE_CHILDREN),
+static WORD_CANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("w"),
         dictgen::InsensitiveStr::Ascii("ws"),
@@ -203102,12 +203102,12 @@ pub static WORD_CANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CAND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAND_CHILDREN),
+static WORD_CAND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAND_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adate"),
         dictgen::InsensitiveStr::Ascii("adates"),
@@ -203151,12 +203151,12 @@ pub static WORD_CAND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_CANC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANC_CHILDREN),
+static WORD_CANC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elability"),
         dictgen::InsensitiveStr::Ascii("elaltion"),
@@ -203214,12 +203214,12 @@ pub static WORD_CANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CANA_CHILDREN),
+static WORD_CANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CANA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CANA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bel"),
         dictgen::InsensitiveStr::Ascii("bels"),
@@ -203257,12 +203257,12 @@ pub static WORD_CANA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAM_CHILDREN),
+static WORD_CAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aera"),
         dictgen::InsensitiveStr::Ascii("apign"),
@@ -203378,12 +203378,12 @@ pub static WORD_CAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_CAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CAL_CHILDREN),
+static WORD_CAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CAL_CHILDREN),
     value: None,
 };
 
-static WORD_CAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CALA_NODE),
     Some(&WORD_CALB_NODE),
     Some(&WORD_CALC_NODE),
@@ -203412,23 +203412,23 @@ static WORD_CAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALY_CHILDREN),
+static WORD_CALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALY_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("more")],
     values: &[&["claymore"]],
     range: 4..=4,
 };
 
-static WORD_CALU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALU_CHILDREN),
+static WORD_CALU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALU_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("calte"),
         dictgen::InsensitiveStr::Ascii("calted"),
@@ -203504,12 +203504,12 @@ pub static WORD_CALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALS_CHILDREN),
+static WORD_CALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -203527,12 +203527,12 @@ pub static WORD_CALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_CALR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALR_CHILDREN),
+static WORD_CALR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ification"),
         dictgen::InsensitiveStr::Ascii("ify"),
@@ -203552,23 +203552,23 @@ pub static WORD_CALR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_CALO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALO_CHILDREN),
+static WORD_CALO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALO_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ires")],
     values: &[&["calories"]],
     range: 4..=4,
 };
 
-static WORD_CALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALL_CHILDREN),
+static WORD_CALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abck"),
         dictgen::InsensitiveStr::Ascii("abcks"),
@@ -203654,12 +203654,12 @@ pub static WORD_CALL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALI_CHILDREN),
+static WORD_CALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ased"),
         dictgen::InsensitiveStr::Ascii("bartion"),
@@ -203737,23 +203737,23 @@ pub static WORD_CALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_CALG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALG_CHILDREN),
+static WORD_CALG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALG_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arry")],
     values: &[&["calgary"]],
     range: 4..=4,
 };
 
-static WORD_CALF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALF_CHILDREN),
+static WORD_CALF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALF_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("es"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -203762,12 +203762,12 @@ pub static WORD_CALF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_CALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALE_CHILDREN),
+static WORD_CALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -203789,12 +203789,12 @@ pub static WORD_CALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_CALC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CALC_CHILDREN),
+static WORD_CALC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CALC_CHILDREN),
     value: None,
 };
 
-static WORD_CALC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CALC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CALCA_NODE),
     None,
     None,
@@ -203823,12 +203823,12 @@ static WORD_CALC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CALCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_CALCU_CHILDREN),
+static WORD_CALCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_CALCU_CHILDREN),
     value: None,
 };
 
-static WORD_CALCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_CALCU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_CALCUA_NODE),
     None,
     None,
@@ -203857,12 +203857,12 @@ static WORD_CALCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_CALCUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUT_CHILDREN),
+static WORD_CALCUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -203880,12 +203880,12 @@ pub static WORD_CALCUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_CALCUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUR_CHILDREN),
+static WORD_CALCUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -203901,12 +203901,12 @@ pub static WORD_CALCUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_CALCUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUL_CHILDREN),
+static WORD_CALCUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ador"),
         dictgen::InsensitiveStr::Ascii("aion"),
@@ -203986,23 +203986,23 @@ pub static WORD_CALCUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_CALCUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUI_CHILDREN),
+static WORD_CALCUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("m")],
     values: &[&["calcium"]],
     range: 1..=1,
 };
 
-static WORD_CALCUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCUA_CHILDREN),
+static WORD_CALCUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("late"),
         dictgen::InsensitiveStr::Ascii("lated"),
@@ -204056,12 +204056,12 @@ pub static WORD_CALCUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=7,
 };
 
-static WORD_CALCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCL_CHILDREN),
+static WORD_CALCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("uate"),
@@ -204093,12 +204093,12 @@ pub static WORD_CALCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_CALCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCI_CHILDREN),
+static WORD_CALCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ulate"),
         dictgen::InsensitiveStr::Ascii("ulating"),
@@ -204107,23 +204107,23 @@ pub static WORD_CALCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_CALCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCE_CHILDREN),
+static WORD_CALCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("l")],
     values: &[&["cancel"]],
     range: 1..=1,
 };
 
-static WORD_CALCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALCA_CHILDREN),
+static WORD_CALCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("late"),
@@ -204132,12 +204132,12 @@ pub static WORD_CALCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CALB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALB_CHILDREN),
+static WORD_CALB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("irate"),
@@ -204165,12 +204165,12 @@ pub static WORD_CALB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_CALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CALA_CHILDREN),
+static WORD_CALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("gry"),
@@ -204181,12 +204181,12 @@ pub static WORD_CALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_CAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAI_CHILDREN),
+static WORD_CAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lbration"),
         dictgen::InsensitiveStr::Ascii("lbre"),
@@ -204196,12 +204196,12 @@ pub static WORD_CAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_CAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAH_CHILDREN),
+static WORD_CAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acter"),
         dictgen::InsensitiveStr::Ascii("acters"),
@@ -204313,12 +204313,12 @@ pub static WORD_CAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_CAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAF_CHILDREN),
+static WORD_CAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAF_CHILDREN),
     value: Some(&["calf"]),
 };
 
-pub static WORD_CAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -204350,12 +204350,12 @@ pub static WORD_CAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_CAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAE_CHILDREN),
+static WORD_CAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fully"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -204373,23 +204373,23 @@ pub static WORD_CAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_CAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAD_CHILDREN),
+static WORD_CAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("idate")],
     values: &[&["candidate"]],
     range: 5..=5,
 };
 
-static WORD_CAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAC_CHILDREN),
+static WORD_CAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahe"),
         dictgen::InsensitiveStr::Ascii("ahes"),
@@ -204497,12 +204497,12 @@ pub static WORD_CAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_CAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAB_CHILDREN),
+static WORD_CAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abge"),
         dictgen::InsensitiveStr::Ascii("abilities"),
@@ -204538,23 +204538,23 @@ pub static WORD_CAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_CAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_CAA_CHILDREN),
+static WORD_CAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_CAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_CAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_CAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ds")],
     values: &[&["cards"]],
     range: 2..=2,
 };
 
-static WORD_B_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_B_CHILDREN),
+static WORD_B_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_B_CHILDREN),
     value: None,
 };
 
-static WORD_B_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_B_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BA_NODE),
     Some(&WORD_BB_NODE),
     Some(&WORD_BC_NODE),
@@ -204583,23 +204583,23 @@ static WORD_B_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BZ_NODE),
 ];
 
-static WORD_BZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BZ_CHILDREN),
+static WORD_BZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iped")],
     values: &[&["bzipped"]],
     range: 4..=4,
 };
 
-static WORD_BY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BY_CHILDREN),
+static WORD_BY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("cicle"),
@@ -204637,34 +204637,34 @@ pub static WORD_BY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_BW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BW_CHILDREN),
+static WORD_BW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tween")],
     values: &[&["between"]],
     range: 5..=5,
 };
 
-static WORD_BV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BV_CHILDREN),
+static WORD_BV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BV_CHILDREN),
     value: None,
 };
 
-pub static WORD_BV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["be"]],
     range: 1..=1,
 };
 
-static WORD_BU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BU_CHILDREN),
+static WORD_BU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BU_CHILDREN),
     value: None,
 };
 
-static WORD_BU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BUA_NODE),
     Some(&WORD_BUB_NODE),
     None,
@@ -204693,23 +204693,23 @@ static WORD_BU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BUZ_NODE),
 ];
 
-static WORD_BUZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUZ_CHILDREN),
+static WORD_BUZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("illa")],
     values: &[&["bugzilla"]],
     range: 4..=4,
 };
 
-static WORD_BUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUU_CHILDREN),
+static WORD_BUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fers"),
         dictgen::InsensitiveStr::Ascii("ild"),
@@ -204720,12 +204720,12 @@ pub static WORD_BUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUT_CHILDREN),
+static WORD_BUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cherd"),
         dictgen::InsensitiveStr::Ascii("hcered"),
@@ -204795,12 +204795,12 @@ pub static WORD_BUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUS_CHILDREN),
+static WORD_BUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ienss"),
         dictgen::InsensitiveStr::Ascii("inees"),
@@ -204846,12 +204846,12 @@ pub static WORD_BUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUR_CHILDREN),
+static WORD_BUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bon"),
         dictgen::InsensitiveStr::Ascii("eacuracy"),
@@ -204957,23 +204957,23 @@ pub static WORD_BUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_BUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUO_CHILDREN),
+static WORD_BUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ancy")],
     values: &[&["buoyancy"]],
     range: 4..=4,
 };
 
-static WORD_BUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUN_CHILDREN),
+static WORD_BUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ble"),
         dictgen::InsensitiveStr::Ascii("bled"),
@@ -205013,12 +205013,12 @@ pub static WORD_BUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_BUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUM_CHILDREN),
+static WORD_BUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("b"),
         dictgen::InsensitiveStr::Ascii("bed"),
@@ -205046,12 +205046,12 @@ pub static WORD_BUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_BUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUL_CHILDREN),
+static WORD_BUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agria"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -205131,12 +205131,12 @@ pub static WORD_BUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_BUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUI_CHILDREN),
+static WORD_BUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUI_CHILDREN),
     value: Some(&["buoy", "buy"]),
 };
 
-pub static WORD_BUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("der"),
@@ -205246,12 +205246,12 @@ pub static WORD_BUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_BUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUH_CHILDREN),
+static WORD_BUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ddism"),
         dictgen::InsensitiveStr::Ascii("ddist"),
@@ -205261,12 +205261,12 @@ pub static WORD_BUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_BUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUG_CHILDREN),
+static WORD_BUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dets"),
         dictgen::InsensitiveStr::Ascii("et"),
@@ -205294,12 +205294,12 @@ pub static WORD_BUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_BUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUF_CHILDREN),
+static WORD_BUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efr"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -205347,12 +205347,12 @@ pub static WORD_BUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BUE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUE_CHILDREN),
+static WORD_BUE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arucratic"),
         dictgen::InsensitiveStr::Ascii("arucrats"),
@@ -205370,12 +205370,12 @@ pub static WORD_BUE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=9,
 };
 
-static WORD_BUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUD_CHILDREN),
+static WORD_BUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("dah"),
@@ -205415,12 +205415,12 @@ pub static WORD_BUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_BUB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUB_CHILDREN),
+static WORD_BUB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bels"),
         dictgen::InsensitiveStr::Ascii("bless"),
@@ -205430,23 +205430,23 @@ pub static WORD_BUB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_BUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BUA_CHILDREN),
+static WORD_BUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["baud"]],
     range: 1..=1,
 };
 
-static WORD_BT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BT_CHILDREN),
+static WORD_BT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iched"),
         dictgen::InsensitiveStr::Ascii("iches"),
@@ -205466,12 +205466,12 @@ pub static WORD_BT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_BS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BS_CHILDREN),
+static WORD_BS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aically"),
         dictgen::InsensitiveStr::Ascii("uiness"),
@@ -205480,12 +205480,12 @@ pub static WORD_BS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_BR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BR_CHILDREN),
+static WORD_BR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BR_CHILDREN),
     value: None,
 };
 
-static WORD_BR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BRA_NODE),
     None,
     None,
@@ -205514,12 +205514,12 @@ static WORD_BR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BRW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRW_CHILDREN),
+static WORD_BRW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("osable"),
         dictgen::InsensitiveStr::Ascii("ose"),
@@ -205539,12 +205539,12 @@ pub static WORD_BRW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_BRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRU_CHILDREN),
+static WORD_BRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghtness"),
         dictgen::InsensitiveStr::Ascii("glar"),
@@ -205596,23 +205596,23 @@ pub static WORD_BRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRT_CHILDREN),
+static WORD_BRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ually")],
     values: &[&["brutally"]],
     range: 5..=5,
 };
 
-static WORD_BRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BRO_CHILDREN),
+static WORD_BRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BRO_CHILDREN),
     value: None,
 };
 
-static WORD_BRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BRO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BROA_NODE),
     Some(&WORD_BROB_NODE),
     Some(&WORD_BROC_NODE),
@@ -205641,12 +205641,12 @@ static WORD_BRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BROW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROW_CHILDREN),
+static WORD_BROW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -205686,12 +205686,12 @@ pub static WORD_BROW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_BROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROU_CHILDREN),
+static WORD_BROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gh"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -205700,12 +205700,12 @@ pub static WORD_BROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BROT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROT_CHILDREN),
+static WORD_BROT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("herhod"),
         dictgen::InsensitiveStr::Ascii("herhoood"),
@@ -205721,12 +205721,12 @@ pub static WORD_BROT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_BROS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROS_CHILDREN),
+static WORD_BROS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -205758,12 +205758,12 @@ pub static WORD_BROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROO_CHILDREN),
+static WORD_BROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("z"),
         dictgen::InsensitiveStr::Ascii("zes"),
@@ -205772,12 +205772,12 @@ pub static WORD_BROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_BRON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRON_CHILDREN),
+static WORD_BRON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRON_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("coes"),
         dictgen::InsensitiveStr::Ascii("ken"),
@@ -205787,12 +205787,12 @@ pub static WORD_BRON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BROK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROK_CHILDREN),
+static WORD_BROK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("em"),
@@ -205810,12 +205810,12 @@ pub static WORD_BROK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BROG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROG_CHILDREN),
+static WORD_BROG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -205824,12 +205824,12 @@ pub static WORD_BROG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_BROD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROD_CHILDREN),
+static WORD_BROD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("away"),
         dictgen::InsensitiveStr::Ascii("cast"),
@@ -205839,12 +205839,12 @@ pub static WORD_BROD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_BROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROC_CHILDREN),
+static WORD_BROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("her"),
         dictgen::InsensitiveStr::Ascii("ken"),
@@ -205866,23 +205866,23 @@ pub static WORD_BROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_BROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROB_CHILDREN),
+static WORD_BROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lematic")],
     values: &[&["problematic"]],
     range: 7..=7,
 };
 
-static WORD_BROA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BROA_CHILDREN),
+static WORD_BROA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BROA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BROA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cast"),
         dictgen::InsensitiveStr::Ascii("casted"),
@@ -205924,12 +205924,12 @@ pub static WORD_BROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_BRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRN_CHILDREN),
+static WORD_BRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ach"),
         dictgen::InsensitiveStr::Ascii("aches"),
@@ -205938,12 +205938,12 @@ pub static WORD_BRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRI_CHILDREN),
+static WORD_BRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agde"),
         dictgen::InsensitiveStr::Ascii("aner"),
@@ -206069,23 +206069,23 @@ pub static WORD_BRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BRF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRF_CHILDREN),
+static WORD_BRF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ore")],
     values: &[&["before"]],
     range: 3..=3,
 };
 
-static WORD_BRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRE_CHILDREN),
+static WORD_BRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRE_CHILDREN),
     value: Some(&["be", "brie"]),
 };
 
-pub static WORD_BRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("adcumbs"),
@@ -206197,12 +206197,12 @@ pub static WORD_BRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_BRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BRA_CHILDREN),
+static WORD_BRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BRA_CHILDREN),
     value: None,
 };
 
-static WORD_BRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BRA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     Some(&WORD_BRAB_NODE),
     Some(&WORD_BRAC_NODE),
@@ -206231,12 +206231,12 @@ static WORD_BRA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BRAZ_NODE),
 ];
 
-static WORD_BRAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAZ_CHILDREN),
+static WORD_BRAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eer"),
         dictgen::InsensitiveStr::Ascii("ilains"),
@@ -206266,45 +206266,45 @@ pub static WORD_BRAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_BRAV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAV_CHILDREN),
+static WORD_BRAV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAV_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erly")],
     values: &[&["bravery"]],
     range: 4..=4,
 };
 
-static WORD_BRAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAT_CHILDREN),
+static WORD_BRAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("enders")],
     values: &[&["bartenders"]],
     range: 6..=6,
 };
 
-static WORD_BRAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAS_CHILDREN),
+static WORD_BRAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("illian")],
     values: &[&["brazilian"]],
     range: 6..=6,
 };
 
-static WORD_BRAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAO_CHILDREN),
+static WORD_BRAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dband"),
         dictgen::InsensitiveStr::Ascii("dcast"),
@@ -206330,12 +206330,12 @@ pub static WORD_BRAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_BRAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAN_CHILDREN),
+static WORD_BRAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("ce"),
@@ -206373,23 +206373,23 @@ pub static WORD_BRAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BRAM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAM_CHILDREN),
+static WORD_BRAM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ches")],
     values: &[&["branches"]],
     range: 4..=4,
 };
 
-static WORD_BRAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAK_CHILDREN),
+static WORD_BRAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edowns"),
         dictgen::InsensitiveStr::Ascii("eout"),
@@ -206413,12 +206413,12 @@ pub static WORD_BRAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_BRAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAI_CHILDREN),
+static WORD_BRAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nwahsed"),
         dictgen::InsensitiveStr::Ascii("nwahsing"),
@@ -206436,23 +206436,23 @@ pub static WORD_BRAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_BRAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAE_CHILDREN),
+static WORD_BRAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("vry")],
     values: &[&["bravery"]],
     range: 3..=3,
 };
 
-static WORD_BRAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAD_CHILDREN),
+static WORD_BRAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cast"),
         dictgen::InsensitiveStr::Ascii("frod"),
@@ -206461,12 +206461,12 @@ pub static WORD_BRAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_BRAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAC_CHILDREN),
+static WORD_BRAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eletes"),
         dictgen::InsensitiveStr::Ascii("elettes"),
@@ -206508,23 +206508,23 @@ pub static WORD_BRAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_BRAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BRAB_CHILDREN),
+static WORD_BRAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BRAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BRAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BRAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("arian")],
     values: &[&["barbarian"]],
     range: 5..=5,
 };
 
-static WORD_BO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BO_CHILDREN),
+static WORD_BO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BO_CHILDREN),
     value: None,
 };
 
-static WORD_BO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BOA_NODE),
     Some(&WORD_BOB_NODE),
     Some(&WORD_BOC_NODE),
@@ -206553,12 +206553,12 @@ static WORD_BO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOY_CHILDREN),
+static WORD_BOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ant"),
         dictgen::InsensitiveStr::Ascii("cot"),
@@ -206588,12 +206588,12 @@ pub static WORD_BOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOX_CHILDREN),
+static WORD_BOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -206602,12 +206602,12 @@ pub static WORD_BOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=1,
 };
 
-static WORD_BOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOW_CHILDREN),
+static WORD_BOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("kay"),
         dictgen::InsensitiveStr::Ascii("kays"),
@@ -206616,12 +206616,12 @@ pub static WORD_BOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_BOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BOU_CHILDREN),
+static WORD_BOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BOU_CHILDREN),
     value: None,
 };
 
-static WORD_BOU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BOU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_BOUC_NODE),
@@ -206650,12 +206650,12 @@ static WORD_BOU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BOUY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUY_CHILDREN),
+static WORD_BOUY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUY_CHILDREN),
     value: Some(&["buoy"]),
 };
 
-pub static WORD_BOUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ancy"),
         dictgen::InsensitiveStr::Ascii("ant"),
@@ -206664,12 +206664,12 @@ pub static WORD_BOUY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BOUU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUU_CHILDREN),
+static WORD_BOUU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("nded"),
@@ -206680,12 +206680,12 @@ pub static WORD_BOUU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BOUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUT_CHILDREN),
+static WORD_BOUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iqe"),
         dictgen::InsensitiveStr::Ascii("nies"),
@@ -206695,12 +206695,12 @@ pub static WORD_BOUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BOUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUR_CHILDREN),
+static WORD_BOUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egois"),
         dictgen::InsensitiveStr::Ascii("geios"),
@@ -206718,23 +206718,23 @@ pub static WORD_BOUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_BOUQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUQ_CHILDREN),
+static WORD_BOUQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("et")],
     values: &[&["bouquet"]],
     range: 2..=2,
 };
 
-static WORD_BOUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BOUN_CHILDREN),
+static WORD_BOUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BOUN_CHILDREN),
     value: Some(&["bound"]),
 };
 
-static WORD_BOUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BOUN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BOUNA_NODE),
     Some(&WORD_BOUNB_NODE),
     None,
@@ -206763,12 +206763,12 @@ static WORD_BOUN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BOUNU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNU_CHILDREN),
+static WORD_BOUNU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daries"),
         dictgen::InsensitiveStr::Ascii("dary"),
@@ -206778,12 +206778,12 @@ pub static WORD_BOUNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BOUNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNT_CHILDREN),
+static WORD_BOUNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNT_CHILDREN),
     value: Some(&["bound"]),
 };
 
-pub static WORD_BOUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ries"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -206792,12 +206792,12 @@ pub static WORD_BOUNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_BOUNS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNS_CHILDREN),
+static WORD_BOUNS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNS_CHILDREN),
     value: Some(&["bounds"]),
 };
 
-pub static WORD_BOUNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aries"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -206808,12 +206808,12 @@ pub static WORD_BOUNS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BOUNR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNR_CHILDREN),
+static WORD_BOUNR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adies"),
         dictgen::InsensitiveStr::Ascii("ady"),
@@ -206833,12 +206833,12 @@ pub static WORD_BOUNR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BOUNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNN_CHILDREN),
+static WORD_BOUNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("daries"),
@@ -206858,12 +206858,12 @@ pub static WORD_BOUNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BOUNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNI_CHILDREN),
+static WORD_BOUNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dng"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -206873,12 +206873,12 @@ pub static WORD_BOUNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BOUNH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNH_CHILDREN),
+static WORD_BOUNH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daries"),
         dictgen::InsensitiveStr::Ascii("dary"),
@@ -206887,12 +206887,12 @@ pub static WORD_BOUNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_BOUNG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNG_CHILDREN),
+static WORD_BOUNG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aries"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -206903,23 +206903,23 @@ pub static WORD_BOUNG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BOUNE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNE_CHILDREN),
+static WORD_BOUNE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["bounded"]],
     range: 1..=1,
 };
 
-static WORD_BOUND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUND_CHILDREN),
+static WORD_BOUND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUND_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aires"),
         dictgen::InsensitiveStr::Ascii("ares"),
@@ -206959,12 +206959,12 @@ pub static WORD_BOUND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_BOUNB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNB_CHILDREN),
+static WORD_BOUNB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daries"),
         dictgen::InsensitiveStr::Ascii("dary"),
@@ -206973,12 +206973,12 @@ pub static WORD_BOUNB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_BOUNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUNA_CHILDREN),
+static WORD_BOUNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aries"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -207014,23 +207014,23 @@ pub static WORD_BOUNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BOUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUL_CHILDREN),
+static WORD_BOUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("dore")],
     values: &[&["boulder"]],
     range: 4..=4,
 };
 
-static WORD_BOUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUI_CHILDREN),
+static WORD_BOUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("nded"),
@@ -207041,12 +207041,12 @@ pub static WORD_BOUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BOUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUD_CHILDREN),
+static WORD_BOUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aries"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -207072,12 +207072,12 @@ pub static WORD_BOUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BOUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOUC_CHILDREN),
+static WORD_BOUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -207088,12 +207088,12 @@ pub static WORD_BOUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_BOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOT_CHILDREN),
+static WORD_BOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("he"),
         dictgen::InsensitiveStr::Ascii("hs"),
@@ -207149,12 +207149,12 @@ pub static WORD_BOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOS_CHILDREN),
+static WORD_BOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lter"),
         dictgen::InsensitiveStr::Ascii("tom"),
@@ -207163,12 +207163,12 @@ pub static WORD_BOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_BOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOR_CHILDREN),
+static WORD_BOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aches"),
         dictgen::InsensitiveStr::Ascii("ad"),
@@ -207234,23 +207234,23 @@ pub static WORD_BOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_BOQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOQ_CHILDREN),
+static WORD_BOQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uet")],
     values: &[&["bouquet"]],
     range: 3..=3,
 };
 
-static WORD_BOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BOO_CHILDREN),
+static WORD_BOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BOO_CHILDREN),
     value: None,
 };
 
-static WORD_BOO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BOO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BOOA_NODE),
     None,
     None,
@@ -207279,12 +207279,12 @@ static WORD_BOO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BOOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOU_CHILDREN),
+static WORD_BOOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nd"),
         dictgen::InsensitiveStr::Ascii("ndaries"),
@@ -207295,12 +207295,12 @@ pub static WORD_BOOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_BOOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOT_CHILDREN),
+static WORD_BOOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eek"),
         dictgen::InsensitiveStr::Ascii("laoder"),
@@ -207336,12 +207336,12 @@ pub static WORD_BOOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_BOOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOS_CHILDREN),
+static WORD_BOOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("helf"),
         dictgen::InsensitiveStr::Ascii("helves"),
@@ -207363,23 +207363,23 @@ pub static WORD_BOOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_BOOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOR_CHILDREN),
+static WORD_BOOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("jwazee")],
     values: &[&["bourgeoisie"]],
     range: 6..=6,
 };
 
-static WORD_BOOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOO_CHILDREN),
+static WORD_BOOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("k"),
         dictgen::InsensitiveStr::Ascii("lean"),
@@ -207389,12 +207389,12 @@ pub static WORD_BOOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BOOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOM_CHILDREN),
+static WORD_BOOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ark"),
         dictgen::InsensitiveStr::Ascii("arks"),
@@ -207403,12 +207403,12 @@ pub static WORD_BOOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BOOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOL_CHILDREN),
+static WORD_BOOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -207442,12 +207442,12 @@ pub static WORD_BOOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_BOOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOK_CHILDREN),
+static WORD_BOOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amrks"),
         dictgen::InsensitiveStr::Ascii("eeping"),
@@ -207479,12 +207479,12 @@ pub static WORD_BOOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_BOOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOF_CHILDREN),
+static WORD_BOOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -207493,12 +207493,12 @@ pub static WORD_BOOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BOOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOE_CHILDREN),
+static WORD_BOOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOE_CHILDREN),
     value: Some(&["buoy"]),
 };
 
-pub static WORD_BOOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -207514,34 +207514,34 @@ pub static WORD_BOOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_BOOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOD_CHILDREN),
+static WORD_BOOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOD_CHILDREN),
     value: Some(&["boot"]),
 };
 
-pub static WORD_BOOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("a")],
     values: &[&["buddha"]],
     range: 1..=1,
 };
 
-static WORD_BOOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOOA_CHILDREN),
+static WORD_BOOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rd")],
     values: &[&["board"]],
     range: 2..=2,
 };
 
-static WORD_BON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BON_CHILDREN),
+static WORD_BON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BON_CHILDREN),
     value: None,
 };
 
-pub static WORD_BON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dary"),
         dictgen::InsensitiveStr::Ascii("nano"),
@@ -207551,12 +207551,12 @@ pub static WORD_BON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=4,
 };
 
-static WORD_BOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOM_CHILDREN),
+static WORD_BOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bardeada"),
         dictgen::InsensitiveStr::Ascii("bardeado"),
@@ -207576,12 +207576,12 @@ pub static WORD_BOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_BOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOL_CHILDREN),
+static WORD_BOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ean"),
         dictgen::InsensitiveStr::Ascii("een"),
@@ -207599,23 +207599,23 @@ pub static WORD_BOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_BOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOK_CHILDREN),
+static WORD_BOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("marks")],
     values: &[&["bookmarks"]],
     range: 5..=5,
 };
 
-static WORD_BOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOI_CHILDREN),
+static WORD_BOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("des"),
         dictgen::InsensitiveStr::Ascii("erplate"),
@@ -207633,12 +207633,12 @@ pub static WORD_BOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOG_CHILDREN),
+static WORD_BOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anveelia"),
         dictgen::InsensitiveStr::Ascii("anveelias"),
@@ -207656,12 +207656,12 @@ pub static WORD_BOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOF_CHILDREN),
+static WORD_BOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ere"),
         dictgen::InsensitiveStr::Ascii("fer"),
@@ -207672,12 +207672,12 @@ pub static WORD_BOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_BOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOE_CHILDREN),
+static WORD_BOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lean"),
         dictgen::InsensitiveStr::Ascii("leans"),
@@ -207686,12 +207686,12 @@ pub static WORD_BOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_BOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOD_CHILDREN),
+static WORD_BOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dy"),
         dictgen::InsensitiveStr::Ascii("iese"),
@@ -207725,23 +207725,23 @@ pub static WORD_BOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOC_CHILDREN),
+static WORD_BOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ome")],
     values: &[&["become"]],
     range: 3..=3,
 };
 
-static WORD_BOB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOB_CHILDREN),
+static WORD_BOB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("mers"),
@@ -207751,12 +207751,12 @@ pub static WORD_BOB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_BOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BOA_CHILDREN),
+static WORD_BOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ds"),
         dictgen::InsensitiveStr::Ascii("rdband"),
@@ -207778,12 +207778,12 @@ pub static WORD_BOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BN_CHILDREN),
+static WORD_BN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ack"),
         dictgen::InsensitiveStr::Ascii("ecause"),
@@ -207793,12 +207793,12 @@ pub static WORD_BN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_BL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BL_CHILDREN),
+static WORD_BL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BL_CHILDREN),
     value: None,
 };
 
-static WORD_BL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BLA_NODE),
     Some(&WORD_BLB_NODE),
     Some(&WORD_BLC_NODE),
@@ -207827,12 +207827,12 @@ static WORD_BL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLU_CHILDREN),
+static WORD_BLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ebarries"),
         dictgen::InsensitiveStr::Ascii("eberies"),
@@ -207880,12 +207880,12 @@ pub static WORD_BLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLO_CHILDREN),
+static WORD_BLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("aded"),
@@ -208005,12 +208005,12 @@ pub static WORD_BLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_BLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLI_CHILDREN),
+static WORD_BLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eve"),
         dictgen::InsensitiveStr::Ascii("ndy"),
@@ -208030,12 +208030,12 @@ pub static WORD_BLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_BLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLE_CHILDREN),
+static WORD_BLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ading"),
         dictgen::InsensitiveStr::Ascii("gian"),
@@ -208061,12 +208061,12 @@ pub static WORD_BLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_BLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLC_CHILDREN),
+static WORD_BLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ok"),
         dictgen::InsensitiveStr::Ascii("oks"),
@@ -208075,23 +208075,23 @@ pub static WORD_BLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_BLB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLB_CHILDREN),
+static WORD_BLB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("os")],
     values: &[&["blobs"]],
     range: 2..=2,
 };
 
-static WORD_BLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BLA_CHILDREN),
+static WORD_BLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckade"),
         dictgen::InsensitiveStr::Ascii("ckahwks"),
@@ -208189,12 +208189,12 @@ pub static WORD_BLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_BJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BJ_CHILDREN),
+static WORD_BJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ect"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -208203,12 +208203,12 @@ pub static WORD_BJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_BI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BI_CHILDREN),
+static WORD_BI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BI_CHILDREN),
     value: None,
 };
 
-static WORD_BI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BIA_NODE),
     Some(&WORD_BIB_NODE),
     Some(&WORD_BIC_NODE),
@@ -208237,12 +208237,12 @@ static WORD_BI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BIZ_NODE),
 ];
 
-static WORD_BIZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIZ_CHILDREN),
+static WORD_BIZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("arely"),
@@ -208260,12 +208260,12 @@ pub static WORD_BIZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_BIY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIY_CHILDREN),
+static WORD_BIY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ou"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -208274,12 +208274,12 @@ pub static WORD_BIY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_BIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIV_CHILDREN),
+static WORD_BIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIV_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ouaced"),
         dictgen::InsensitiveStr::Ascii("ouacing"),
@@ -208289,23 +208289,23 @@ pub static WORD_BIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_BIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIU_CHILDREN),
+static WORD_BIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lt")],
     values: &[&["built", "build"]],
     range: 2..=2,
 };
 
-static WORD_BIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIT_CHILDREN),
+static WORD_BIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amps"),
         dictgen::InsensitiveStr::Ascii("ap"),
@@ -208367,12 +208367,12 @@ pub static WORD_BIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIS_CHILDREN),
+static WORD_BIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cut"),
@@ -208406,12 +208406,12 @@ pub static WORD_BIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIR_CHILDREN),
+static WORD_BIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("damn"),
         dictgen::InsensitiveStr::Ascii("dges"),
@@ -208459,23 +208459,23 @@ pub static WORD_BIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=13,
 };
 
-static WORD_BIP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIP_CHILDREN),
+static WORD_BIP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIP_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("loar")],
     values: &[&["bipolar"]],
     range: 4..=4,
 };
 
-static WORD_BIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIO_CHILDREN),
+static WORD_BIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gted"),
         dictgen::InsensitiveStr::Ascii("gtry"),
@@ -208503,12 +208503,12 @@ pub static WORD_BIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_BIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIN_CHILDREN),
+static WORD_BIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("airy"),
         dictgen::InsensitiveStr::Ascii("anary"),
@@ -208536,12 +208536,12 @@ pub static WORD_BIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIM_CHILDREN),
+static WORD_BIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ask"),
         dictgen::InsensitiveStr::Ascii("illenia"),
@@ -208559,12 +208559,12 @@ pub static WORD_BIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIL_CHILDREN),
+static WORD_BIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angual"),
         dictgen::InsensitiveStr::Ascii("ateraly"),
@@ -208614,34 +208614,34 @@ pub static WORD_BIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_BIJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIJ_CHILDREN),
+static WORD_BIJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cetive")],
     values: &[&["bijective"]],
     range: 6..=6,
 };
 
-static WORD_BII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BII_CHILDREN),
+static WORD_BII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BII_CHILDREN),
     value: None,
 };
 
-pub static WORD_BII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nary")],
     values: &[&["binary"]],
     range: 4..=4,
 };
 
-static WORD_BIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIG_CHILDREN),
+static WORD_BIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("allic"),
         dictgen::InsensitiveStr::Ascii("egr"),
@@ -208671,23 +208671,23 @@ pub static WORD_BIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BIF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIF_CHILDREN),
+static WORD_BIF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("goot")],
     values: &[&["bigfoot"]],
     range: 4..=4,
 };
 
-static WORD_BIE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIE_CHILDREN),
+static WORD_BIE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("jing"),
         dictgen::InsensitiveStr::Ascii("ng"),
@@ -208696,12 +208696,12 @@ pub static WORD_BIE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_BID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BID_CHILDREN),
+static WORD_BID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BID_CHILDREN),
     value: None,
 };
 
-pub static WORD_BID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dings"),
         dictgen::InsensitiveStr::Ascii("imentionnal"),
@@ -208721,12 +208721,12 @@ pub static WORD_BID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=11,
 };
 
-static WORD_BIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIC_CHILDREN),
+static WORD_BIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("thes"),
@@ -208736,23 +208736,23 @@ pub static WORD_BIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIB_CHILDREN),
+static WORD_BIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ilcal")],
     values: &[&["biblical"]],
     range: 5..=5,
 };
 
-static WORD_BIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BIA_CHILDREN),
+static WORD_BIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nries"),
         dictgen::InsensitiveStr::Ascii("nry"),
@@ -208762,34 +208762,34 @@ pub static WORD_BIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_BG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BG_CHILDREN),
+static WORD_BG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inning")],
     values: &[&["beginning"]],
     range: 6..=6,
 };
 
-static WORD_BF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BF_CHILDREN),
+static WORD_BF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("fer")],
     values: &[&["buffer"]],
     range: 3..=3,
 };
 
-static WORD_BE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BE_CHILDREN),
+static WORD_BE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BE_CHILDREN),
     value: None,
 };
 
-static WORD_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BEA_NODE),
     Some(&WORD_BEB_NODE),
     Some(&WORD_BEC_NODE),
@@ -208818,12 +208818,12 @@ static WORD_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEY_CHILDREN),
+static WORD_BEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oncye"),
         dictgen::InsensitiveStr::Ascii("one"),
@@ -208834,12 +208834,12 @@ pub static WORD_BEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BEW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEW_CHILDREN),
+static WORD_BEW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eeen"),
         dictgen::InsensitiveStr::Ascii("een"),
@@ -208850,12 +208850,12 @@ pub static WORD_BEW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=7,
 };
 
-static WORD_BEV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEV_CHILDREN),
+static WORD_BEV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEV_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cause"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -208873,12 +208873,12 @@ pub static WORD_BEV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BEU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEU_CHILDREN),
+static WORD_BEU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atiful"),
         dictgen::InsensitiveStr::Ascii("atifully"),
@@ -208910,12 +208910,12 @@ pub static WORD_BEU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_BET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BET_CHILDREN),
+static WORD_BET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BET_CHILDREN),
     value: None,
 };
 
-pub static WORD_BET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ales"),
         dictgen::InsensitiveStr::Ascii("cause"),
@@ -208995,12 +208995,12 @@ pub static WORD_BET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BES_CHILDREN),
+static WORD_BES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BES_CHILDREN),
     value: None,
 };
 
-pub static WORD_BES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cribed"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -209030,12 +209030,12 @@ pub static WORD_BES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BER_CHILDREN),
+static WORD_BER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BER_CHILDREN),
     value: None,
 };
 
-pub static WORD_BER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aded"),
         dictgen::InsensitiveStr::Ascii("ekley"),
@@ -209069,12 +209069,12 @@ pub static WORD_BER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_BEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEO_CHILDREN),
+static WORD_BEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fre"),
         dictgen::InsensitiveStr::Ascii("nd"),
@@ -209084,12 +209084,12 @@ pub static WORD_BEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_BEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BEN_CHILDREN),
+static WORD_BEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BEN_CHILDREN),
     value: None,
 };
 
-static WORD_BEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BENA_NODE),
     None,
     Some(&WORD_BENC_NODE),
@@ -209118,34 +209118,34 @@ static WORD_BEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BENO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENO_CHILDREN),
+static WORD_BENO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("velent")],
     values: &[&["benevolent"]],
     range: 6..=6,
 };
 
-static WORD_BENN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENN_CHILDREN),
+static WORD_BENN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENN_CHILDREN),
     value: Some(&["been"]),
 };
 
-pub static WORD_BENN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_BENJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENJ_CHILDREN),
+static WORD_BENJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENJ_CHILDREN),
     value: Some(&["binge"]),
 };
 
-pub static WORD_BENJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -209156,12 +209156,12 @@ pub static WORD_BENJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENI_CHILDREN),
+static WORD_BENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dect"),
         dictgen::InsensitiveStr::Ascii("fical"),
@@ -209189,12 +209189,12 @@ pub static WORD_BENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BENH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENH_CHILDREN),
+static WORD_BENH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gazi"),
         dictgen::InsensitiveStr::Ascii("ind"),
@@ -209203,12 +209203,12 @@ pub static WORD_BENH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BENG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENG_CHILDREN),
+static WORD_BENG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENG_CHILDREN),
     value: Some(&["being"]),
 };
 
-pub static WORD_BENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahzi"),
         dictgen::InsensitiveStr::Ascii("alas"),
@@ -209246,12 +209246,12 @@ pub static WORD_BENG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_BENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENF_CHILDREN),
+static WORD_BENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icial"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -209261,12 +209261,12 @@ pub static WORD_BENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENE_CHILDREN),
+static WORD_BENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chmark"),
         dictgen::InsensitiveStr::Ascii("chmarked"),
@@ -209328,12 +209328,12 @@ pub static WORD_BENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_BENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENC_CHILDREN),
+static WORD_BENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hamarked"),
         dictgen::InsensitiveStr::Ascii("hamarking"),
@@ -209383,34 +209383,34 @@ pub static WORD_BENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_BENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BENA_CHILDREN),
+static WORD_BENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gls")],
     values: &[&["bengals"]],
     range: 3..=3,
 };
 
-static WORD_BEM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEM_CHILDREN),
+static WORD_BEM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEM_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("usemnt")],
     values: &[&["bemusement"]],
     range: 6..=6,
 };
 
-static WORD_BEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BEL_CHILDREN),
+static WORD_BEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BEL_CHILDREN),
     value: None,
 };
 
-static WORD_BEL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BEL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -209439,12 +209439,12 @@ static WORD_BEL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BELY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELY_CHILDREN),
+static WORD_BELY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -209462,34 +209462,34 @@ pub static WORD_BELY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_BELW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELW_CHILDREN),
+static WORD_BELW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("o")],
     values: &[&["below"]],
     range: 1..=1,
 };
 
-static WORD_BELS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELS_CHILDREN),
+static WORD_BELS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sings")],
     values: &[&["blessings"]],
     range: 5..=5,
 };
 
-static WORD_BELO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELO_CHILDREN),
+static WORD_BELO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("ging"),
@@ -209513,12 +209513,12 @@ pub static WORD_BELO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_BELL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELL_CHILDREN),
+static WORD_BELL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("igerant"),
         dictgen::InsensitiveStr::Ascii("igerante"),
@@ -209536,12 +209536,12 @@ pub static WORD_BELL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_BELI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELI_CHILDREN),
+static WORD_BELI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avable"),
         dictgen::InsensitiveStr::Ascii("ebable"),
@@ -209609,12 +209609,12 @@ pub static WORD_BELI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_BELG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELG_CHILDREN),
+static WORD_BELG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("uim"),
@@ -209623,12 +209623,12 @@ pub static WORD_BELG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_BELE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELE_CHILDREN),
+static WORD_BELE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BELE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agured"),
         dictgen::InsensitiveStr::Ascii("ave"),
@@ -209680,23 +209680,23 @@ pub static WORD_BELE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_BELD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BELD_CHILDREN),
+static WORD_BELD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BELD_CHILDREN),
     value: Some(&["held"]),
 };
 
-pub static WORD_BELD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BELD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_BEJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEJ_CHILDREN),
+static WORD_BEJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iing"),
         dictgen::InsensitiveStr::Ascii("ond"),
@@ -209705,12 +209705,12 @@ pub static WORD_BEJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_BEI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEI_CHILDREN),
+static WORD_BEI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eve"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -209734,12 +209734,12 @@ pub static WORD_BEI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_BEH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEH_CHILDREN),
+static WORD_BEH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abior"),
         dictgen::InsensitiveStr::Ascii("abiors"),
@@ -209835,12 +209835,12 @@ pub static WORD_BEH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BEG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEG_CHILDREN),
+static WORD_BEG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("ative"),
@@ -209926,12 +209926,12 @@ pub static WORD_BEG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BEF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEF_CHILDREN),
+static WORD_BEF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fer"),
         dictgen::InsensitiveStr::Ascii("ire"),
@@ -209971,12 +209971,12 @@ pub static WORD_BEF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEE_CHILDREN),
+static WORD_BEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("en"),
@@ -210004,12 +210004,12 @@ pub static WORD_BEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_BED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BED_CHILDREN),
+static WORD_BED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BED_CHILDREN),
     value: None,
 };
 
-pub static WORD_BED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ore"),
@@ -210018,12 +210018,12 @@ pub static WORD_BED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=3,
 };
 
-static WORD_BEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEC_CHILDREN),
+static WORD_BEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aause"),
         dictgen::InsensitiveStr::Ascii("acdd"),
@@ -210131,12 +210131,12 @@ pub static WORD_BEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BEB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEB_CHILDREN),
+static WORD_BEB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efore"),
         dictgen::InsensitiveStr::Ascii("ongs"),
@@ -210146,12 +210146,12 @@ pub static WORD_BEB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_BEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BEA_CHILDREN),
+static WORD_BEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("caon"),
         dictgen::InsensitiveStr::Ascii("cause"),
@@ -210259,12 +210259,12 @@ pub static WORD_BEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_BC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BC_CHILDREN),
+static WORD_BC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BC_CHILDREN),
     value: None,
 };
 
-pub static WORD_BC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ak"),
         dictgen::InsensitiveStr::Ascii("ause"),
@@ -210286,12 +210286,12 @@ pub static WORD_BC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_BB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BB_CHILDREN),
+static WORD_BB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efore"),
         dictgen::InsensitiveStr::Ascii("oolean"),
@@ -210301,12 +210301,12 @@ pub static WORD_BB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_BA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BA_CHILDREN),
+static WORD_BA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BA_CHILDREN),
     value: Some(&["by", "be"]),
 };
 
-static WORD_BA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BAA_NODE),
     Some(&WORD_BAB_NODE),
     Some(&WORD_BAC_NODE),
@@ -210335,12 +210335,12 @@ static WORD_BA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_BAZ_NODE),
 ];
 
-static WORD_BAZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAZ_CHILDREN),
+static WORD_BAZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("are"),
         dictgen::InsensitiveStr::Ascii("erk"),
@@ -210349,12 +210349,12 @@ pub static WORD_BAZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=3,
 };
 
-static WORD_BAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAY_CHILDREN),
+static WORD_BAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blon"),
         dictgen::InsensitiveStr::Ascii("ge"),
@@ -210374,23 +210374,23 @@ pub static WORD_BAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BAU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAU_CHILDREN),
+static WORD_BAU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ght")],
     values: &[&["bought"]],
     range: 3..=3,
 };
 
-static WORD_BAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAT_CHILDREN),
+static WORD_BAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chleur"),
         dictgen::InsensitiveStr::Ascii("chleurs"),
@@ -210468,12 +210468,12 @@ pub static WORD_BAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_BAS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAS_CHILDREN),
+static WORD_BAS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ci"),
         dictgen::InsensitiveStr::Ascii("cially"),
@@ -210561,12 +210561,12 @@ pub static WORD_BAS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_BAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAR_CHILDREN),
+static WORD_BAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abrian"),
         dictgen::InsensitiveStr::Ascii("abrians"),
@@ -210674,12 +210674,12 @@ pub static WORD_BAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BAP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAP_CHILDREN),
+static WORD_BAP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAP_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tims"),
         dictgen::InsensitiveStr::Ascii("tisim"),
@@ -210689,12 +210689,12 @@ pub static WORD_BAP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_BAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAO_CHILDREN),
+static WORD_BAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rd"),
         dictgen::InsensitiveStr::Ascii("rdwalk"),
@@ -210705,12 +210705,12 @@ pub static WORD_BAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_BAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAN_CHILDREN),
+static WORD_BAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("annas"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -210788,12 +210788,12 @@ pub static WORD_BAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_BAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAL_CHILDREN),
+static WORD_BAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acing"),
         dictgen::InsensitiveStr::Ascii("anceada"),
@@ -210865,12 +210865,12 @@ pub static WORD_BAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_BAK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAK_CHILDREN),
+static WORD_BAK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAK_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("c"),
         dictgen::InsensitiveStr::Ascii("cers"),
@@ -210902,12 +210902,12 @@ pub static WORD_BAK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_BAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAI_CHILDREN),
+static WORD_BAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sc"),
         dictgen::InsensitiveStr::Ascii("scly"),
@@ -210918,12 +210918,12 @@ pub static WORD_BAI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_BAH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAH_CHILDREN),
+static WORD_BAH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aving"),
         dictgen::InsensitiveStr::Ascii("avior"),
@@ -210941,12 +210941,12 @@ pub static WORD_BAH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_BAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAG_CHILDREN),
+static WORD_BAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -210955,34 +210955,34 @@ pub static WORD_BAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_BAF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAF_CHILDREN),
+static WORD_BAF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ore")],
     values: &[&["before"]],
     range: 3..=3,
 };
 
-static WORD_BAE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAE_CHILDREN),
+static WORD_BAE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["based"]],
     range: 1..=1,
 };
 
-static WORD_BAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAD_CHILDREN),
+static WORD_BAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mitten"),
         dictgen::InsensitiveStr::Ascii("nits"),
@@ -210993,12 +210993,12 @@ pub static WORD_BAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_BAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BAC_CHILDREN),
+static WORD_BAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BAC_CHILDREN),
     value: None,
 };
 
-static WORD_BAC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BAC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BACA_NODE),
     None,
     None,
@@ -211027,12 +211027,12 @@ static WORD_BAC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BACW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACW_CHILDREN),
+static WORD_BACW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ard"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -211041,12 +211041,12 @@ pub static WORD_BACW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_BACU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACU_CHILDREN),
+static WORD_BACU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACU_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("p"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -211055,12 +211055,12 @@ pub static WORD_BACU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_BACT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACT_CHILDREN),
+static WORD_BACT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("racking"),
@@ -211069,23 +211069,23 @@ pub static WORD_BACT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_BACL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACL_CHILDREN),
+static WORD_BACL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACL_CHILDREN),
     value: Some(&["back"]),
 };
 
-pub static WORD_BACL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ony")],
     values: &[&["balcony"]],
     range: 3..=3,
 };
 
-static WORD_BACK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_BACK_CHILDREN),
+static WORD_BACK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_BACK_CHILDREN),
     value: None,
 };
 
-static WORD_BACK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_BACK_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_BACKA_NODE),
     Some(&WORD_BACKB_NODE),
     None,
@@ -211114,12 +211114,12 @@ static WORD_BACK_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_BACKW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKW_CHILDREN),
+static WORD_BACKW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKW_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("ardss"),
@@ -211141,23 +211141,23 @@ pub static WORD_BACKW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BACKT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKT_CHILDREN),
+static WORD_BACKT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKT_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("acking")],
     values: &[&["backpacking"]],
     range: 6..=6,
 };
 
-static WORD_BACKS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKS_CHILDREN),
+static WORD_BACKS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKS_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apce"),
         dictgen::InsensitiveStr::Ascii("lah"),
@@ -211179,12 +211179,12 @@ pub static WORD_BACKS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_BACKR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKR_CHILDREN),
+static WORD_BACKR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKR_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("efence"),
@@ -211206,12 +211206,12 @@ pub static WORD_BACKR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_BACKP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKP_CHILDREN),
+static WORD_BACKP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKP_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acing"),
         dictgen::InsensitiveStr::Ascii("ackng"),
@@ -211231,12 +211231,12 @@ pub static WORD_BACKP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_BACKO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKO_CHILDREN),
+static WORD_BACKO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKO_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("und"),
@@ -211246,12 +211246,12 @@ pub static WORD_BACKO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_BACKN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKN_CHILDREN),
+static WORD_BACKN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKN_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("eds"),
@@ -211260,12 +211260,12 @@ pub static WORD_BACKN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_BACKL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKL_CHILDREN),
+static WORD_BACKL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKL_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ght"),
         dictgen::InsensitiveStr::Ascii("ghting"),
@@ -211275,34 +211275,34 @@ pub static WORD_BACKL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_BACKJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKJ_CHILDREN),
+static WORD_BACKJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("acking")],
     values: &[&["backpacking"]],
     range: 6..=6,
 };
 
-static WORD_BACKH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKH_CHILDREN),
+static WORD_BACKH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("acking")],
     values: &[&["backpacking"]],
     range: 6..=6,
 };
 
-static WORD_BACKG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKG_CHILDREN),
+static WORD_BACKG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orund"),
         dictgen::InsensitiveStr::Ascii("orunds"),
@@ -211362,12 +211362,12 @@ pub static WORD_BACKG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_BACKF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKF_CHILDREN),
+static WORD_BACKF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKF_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eild"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -211383,12 +211383,12 @@ pub static WORD_BACKF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_BACKE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKE_CHILDREN),
+static WORD_BACKE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("dn"),
@@ -211412,12 +211412,12 @@ pub static WORD_BACKE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_BACKD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKD_CHILDREN),
+static WORD_BACKD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKD_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ooor"),
         dictgen::InsensitiveStr::Ascii("or"),
@@ -211426,12 +211426,12 @@ pub static WORD_BACKD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_BACKB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKB_CHILDREN),
+static WORD_BACKB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acking"),
         dictgen::InsensitiveStr::Ascii("round"),
@@ -211441,12 +211441,12 @@ pub static WORD_BACKB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_BACKA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACKA_CHILDREN),
+static WORD_BACKA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACKA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACKA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("loriette"),
         dictgen::InsensitiveStr::Ascii("loriettes"),
@@ -211456,34 +211456,34 @@ pub static WORD_BACKA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_BACJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACJ_CHILDREN),
+static WORD_BACJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("kward")],
     values: &[&["backward"]],
     range: 5..=5,
 };
 
-static WORD_BACI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACI_CHILDREN),
+static WORD_BACI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACI_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("c")],
     values: &[&["basic"]],
     range: 1..=1,
 };
 
-static WORD_BACH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACH_CHILDREN),
+static WORD_BACH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACH_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elores"),
         dictgen::InsensitiveStr::Ascii("elour"),
@@ -211507,23 +211507,23 @@ pub static WORD_BACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_BACG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACG_CHILDREN),
+static WORD_BACG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACG_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("round")],
     values: &[&["background"]],
     range: 5..=5,
 };
 
-static WORD_BACE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACE_CHILDREN),
+static WORD_BACE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACE_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ause"),
         dictgen::InsensitiveStr::Ascii("hlor"),
@@ -211533,23 +211533,23 @@ pub static WORD_BACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_BACA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BACA_CHILDREN),
+static WORD_BACA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BACA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BACA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("use")],
     values: &[&["because"]],
     range: 3..=3,
 };
 
-static WORD_BAB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAB_CHILDREN),
+static WORD_BAB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAB_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("lyon"),
@@ -211573,23 +211573,23 @@ pub static WORD_BAB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_BAA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_BAA_CHILDREN),
+static WORD_BAA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_BAA_CHILDREN),
     value: None,
 };
 
-pub static WORD_BAA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_BAA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("se")],
     values: &[&["abase", "base"]],
     range: 2..=2,
 };
 
-static WORD_A_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_A_CHILDREN),
+static WORD_A_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_A_CHILDREN),
     value: None,
 };
 
-static WORD_A_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_A_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AA_NODE),
     Some(&WORD_AB_NODE),
     Some(&WORD_AC_NODE),
@@ -211618,12 +211618,12 @@ static WORD_A_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_AZ_NODE),
 ];
 
-static WORD_AZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AZ_CHILDREN),
+static WORD_AZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_AZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ma"),
         dictgen::InsensitiveStr::Ascii("mith"),
@@ -211633,12 +211633,12 @@ pub static WORD_AZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_AY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AY_CHILDREN),
+static WORD_AY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AY_CHILDREN),
     value: None,
 };
 
-pub static WORD_AY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nchronous"),
         dictgen::InsensitiveStr::Ascii("snc"),
@@ -211656,12 +211656,12 @@ pub static WORD_AY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_AX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AX_CHILDREN),
+static WORD_AX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AX_CHILDREN),
     value: None,
 };
 
-pub static WORD_AX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ises"),
         dictgen::InsensitiveStr::Ascii("issymmetric"),
@@ -211679,12 +211679,12 @@ pub static WORD_AX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_AW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AW_CHILDREN),
+static WORD_AW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AW_CHILDREN),
     value: None,
 };
 
-pub static WORD_AW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailable"),
         dictgen::InsensitiveStr::Ascii("akend"),
@@ -211766,12 +211766,12 @@ pub static WORD_AW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=13,
 };
 
-static WORD_AV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AV_CHILDREN),
+static WORD_AV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AV_CHILDREN),
     value: None,
 };
 
-static WORD_AV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AVA_NODE),
     None,
     Some(&WORD_AVC_NODE),
@@ -211800,12 +211800,12 @@ static WORD_AV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AVT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVT_CHILDREN),
+static WORD_AVT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aars"),
         dictgen::InsensitiveStr::Ascii("ive"),
@@ -211815,12 +211815,12 @@ pub static WORD_AVT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_AVR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVR_CHILDREN),
+static WORD_AVR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iable"),
         dictgen::InsensitiveStr::Ascii("iables"),
@@ -211831,12 +211831,12 @@ pub static WORD_AVR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_AVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVO_CHILDREN),
+static WORD_AVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("be"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -211874,23 +211874,23 @@ pub static WORD_AVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_AVN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVN_CHILDREN),
+static WORD_AVN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("egers")],
     values: &[&["avengers"]],
     range: 5..=5,
 };
 
-static WORD_AVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVI_CHILDREN),
+static WORD_AVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("aiton"),
@@ -211930,23 +211930,23 @@ pub static WORD_AVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_AVG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVG_CHILDREN),
+static WORD_AVG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erage")],
     values: &[&["average"]],
     range: 5..=5,
 };
 
-static WORD_AVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVE_CHILDREN),
+static WORD_AVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ngence"),
         dictgen::InsensitiveStr::Ascii("nt"),
@@ -211982,12 +211982,12 @@ pub static WORD_AVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_AVD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVD_CHILDREN),
+static WORD_AVD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVD_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isories"),
         dictgen::InsensitiveStr::Ascii("isoriy"),
@@ -212003,12 +212003,12 @@ pub static WORD_AVD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_AVC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVC_CHILDREN),
+static WORD_AVC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oid"),
         dictgen::InsensitiveStr::Ascii("oids"),
@@ -212017,12 +212017,12 @@ pub static WORD_AVC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_AVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AVA_CHILDREN),
+static WORD_AVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AVA_CHILDREN),
     value: None,
 };
 
-static WORD_AVA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AVA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_AVAC_NODE),
@@ -212051,12 +212051,12 @@ static WORD_AVA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AVAT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAT_CHILDREN),
+static WORD_AVAT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aras"),
         dictgen::InsensitiveStr::Ascii("ards"),
@@ -212074,12 +212074,12 @@ pub static WORD_AVAT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_AVAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAR_CHILDREN),
+static WORD_AVAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("ageing"),
@@ -212097,12 +212097,12 @@ pub static WORD_AVAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_AVAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAO_CHILDREN),
+static WORD_AVAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("id"),
         dictgen::InsensitiveStr::Ascii("idable"),
@@ -212112,12 +212112,12 @@ pub static WORD_AVAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_AVAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAN_CHILDREN),
+static WORD_AVAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -212128,12 +212128,12 @@ pub static WORD_AVAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_AVAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAL_CHILDREN),
+static WORD_AVAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -212171,12 +212171,12 @@ pub static WORD_AVAL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_AVAI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AVAI_CHILDREN),
+static WORD_AVAI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AVAI_CHILDREN),
     value: None,
 };
 
-static WORD_AVAI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AVAI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AVAIA_NODE),
     Some(&WORD_AVAIB_NODE),
     None,
@@ -212205,23 +212205,23 @@ static WORD_AVAI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AVAIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAIT_CHILDREN),
+static WORD_AVAIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ion")],
     values: &[&["aviation"]],
     range: 3..=3,
 };
 
-static WORD_AVAIL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAIL_CHILDREN),
+static WORD_AVAIL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAIL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAIL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aable"),
         dictgen::InsensitiveStr::Ascii("abable"),
@@ -212345,12 +212345,12 @@ pub static WORD_AVAIL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_AVAII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAII_CHILDREN),
+static WORD_AVAII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAII_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ability"),
         dictgen::InsensitiveStr::Ascii("able"),
@@ -212368,12 +212368,12 @@ pub static WORD_AVAII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_AVAIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAIB_CHILDREN),
+static WORD_AVAIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ale"),
         dictgen::InsensitiveStr::Ascii("ility"),
@@ -212389,12 +212389,12 @@ pub static WORD_AVAIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_AVAIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAIA_CHILDREN),
+static WORD_AVAIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bility"),
         dictgen::InsensitiveStr::Ascii("ble"),
@@ -212418,12 +212418,12 @@ pub static WORD_AVAIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_AVAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AVAC_CHILDREN),
+static WORD_AVAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AVAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AVAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AVAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ado"),
         dictgen::InsensitiveStr::Ascii("ados"),
@@ -212433,12 +212433,12 @@ pub static WORD_AVAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_AU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AU_CHILDREN),
+static WORD_AU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AU_CHILDREN),
     value: None,
 };
 
-static WORD_AU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_AUC_NODE),
@@ -212467,12 +212467,12 @@ static WORD_AU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUX_CHILDREN),
+static WORD_AUX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUX_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialiary"),
         dictgen::InsensitiveStr::Ascii("ilaries"),
@@ -212510,12 +212510,12 @@ pub static WORD_AUX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_AUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUT_CHILDREN),
+static WORD_AUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUT_CHILDREN),
     value: None,
 };
 
-static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AUTA_NODE),
     None,
     Some(&WORD_AUTC_NODE),
@@ -212544,45 +212544,45 @@ static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTU_CHILDREN),
+static WORD_AUTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("m")],
     values: &[&["autumn"]],
     range: 1..=1,
 };
 
-static WORD_AUTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTT_CHILDREN),
+static WORD_AUTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oatack")],
     values: &[&["autoattack"]],
     range: 6..=6,
 };
 
-static WORD_AUTS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTS_CHILDREN),
+static WORD_AUTS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTS_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itic")],
     values: &[&["autistic"]],
     range: 4..=4,
 };
 
-static WORD_AUTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUTO_CHILDREN),
+static WORD_AUTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUTO_CHILDREN),
     value: None,
 };
 
-static WORD_AUTO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUTO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AUTOA_NODE),
     None,
     Some(&WORD_AUTOC_NODE),
@@ -212611,12 +212611,12 @@ static WORD_AUTO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOT_CHILDREN),
+static WORD_AUTOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orium"),
         dictgen::InsensitiveStr::Ascii("oriums"),
@@ -212625,12 +212625,12 @@ pub static WORD_AUTOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_AUTOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOS_CHILDREN),
+static WORD_AUTOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("avegs"),
@@ -212646,12 +212646,12 @@ pub static WORD_AUTOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=12,
 };
 
-static WORD_AUTOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOR_CHILDREN),
+static WORD_AUTOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOR_CHILDREN),
     value: Some(&["author"]),
 };
 
-pub static WORD_AUTOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ealease"),
         dictgen::InsensitiveStr::Ascii("isation"),
@@ -212675,34 +212675,34 @@ pub static WORD_AUTOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_AUTOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOP_CHILDREN),
+static WORD_AUTOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("sec")],
     values: &[&["autospec"]],
     range: 3..=3,
 };
 
-static WORD_AUTOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOO_CHILDREN),
+static WORD_AUTOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nf")],
     values: &[&["autoconf"]],
     range: 2..=2,
 };
 
-static WORD_AUTON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTON_CHILDREN),
+static WORD_AUTON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTON_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agotiation"),
         dictgen::InsensitiveStr::Ascii("amous"),
@@ -212822,12 +212822,12 @@ pub static WORD_AUTON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=18,
 };
 
-static WORD_AUTOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOM_CHILDREN),
+static WORD_AUTOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aatically"),
         dictgen::InsensitiveStr::Ascii("actically"),
@@ -212951,34 +212951,34 @@ pub static WORD_AUTOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_AUTOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOL_CHILDREN),
+static WORD_AUTOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aod")],
     values: &[&["autoload"]],
     range: 3..=3,
 };
 
-static WORD_AUTOK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOK_CHILDREN),
+static WORD_AUTOK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOK_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orrect")],
     values: &[&["autocorrect"]],
     range: 6..=6,
 };
 
-static WORD_AUTOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOI_CHILDREN),
+static WORD_AUTOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncrememnt"),
         dictgen::InsensitiveStr::Ascii("ncrementive"),
@@ -212988,23 +212988,23 @@ pub static WORD_AUTOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=11,
 };
 
-static WORD_AUTOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOH_CHILDREN),
+static WORD_AUTOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("orized")],
     values: &[&["authorized"]],
     range: 6..=6,
 };
 
-static WORD_AUTOG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOG_CHILDREN),
+static WORD_AUTOG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enrated"),
         dictgen::InsensitiveStr::Ascii("enratet"),
@@ -213026,12 +213026,12 @@ pub static WORD_AUTOG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_AUTOF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOF_CHILDREN),
+static WORD_AUTOF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOF_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilt"),
         dictgen::InsensitiveStr::Ascii("omat"),
@@ -213041,23 +213041,23 @@ pub static WORD_AUTOF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_AUTOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOE_CHILDREN),
+static WORD_AUTOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("select")],
     values: &[&["autoselect"]],
     range: 6..=6,
 };
 
-static WORD_AUTOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOD_CHILDREN),
+static WORD_AUTOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ected"),
         dictgen::InsensitiveStr::Ascii("ection"),
@@ -213066,12 +213066,12 @@ pub static WORD_AUTOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_AUTOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOC_CHILDREN),
+static WORD_AUTOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("htonous"),
         dictgen::InsensitiveStr::Ascii("mplete"),
@@ -213125,12 +213125,12 @@ pub static WORD_AUTOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_AUTOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTOA_CHILDREN),
+static WORD_AUTOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gressive"),
         dictgen::InsensitiveStr::Ascii("mtically"),
@@ -213150,12 +213150,12 @@ pub static WORD_AUTOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_AUTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTM_CHILDREN),
+static WORD_AUTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atic"),
         dictgen::InsensitiveStr::Ascii("atically"),
@@ -213171,12 +213171,12 @@ pub static WORD_AUTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_AUTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTI_CHILDREN),
+static WORD_AUTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("magically"),
         dictgen::InsensitiveStr::Ascii("matic"),
@@ -213198,12 +213198,12 @@ pub static WORD_AUTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_AUTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUTH_CHILDREN),
+static WORD_AUTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUTH_CHILDREN),
     value: None,
 };
 
-static WORD_AUTH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUTH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -213232,23 +213232,23 @@ static WORD_AUTH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTHU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHU_CHILDREN),
+static WORD_AUTHU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("r")],
     values: &[&["author"]],
     range: 1..=1,
 };
 
-static WORD_AUTHR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHR_CHILDREN),
+static WORD_AUTHR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oity"),
         dictgen::InsensitiveStr::Ascii("oization"),
@@ -213274,12 +213274,12 @@ pub static WORD_AUTHR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_AUTHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHO_CHILDREN),
+static WORD_AUTHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("biographic"),
         dictgen::InsensitiveStr::Ascii("biography"),
@@ -213345,12 +213345,12 @@ pub static WORD_AUTHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=12,
 };
 
-static WORD_AUTHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUTHE_CHILDREN),
+static WORD_AUTHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUTHE_CHILDREN),
     value: None,
 };
 
-static WORD_AUTHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUTHE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_AUTHEC_NODE),
@@ -213379,12 +213379,12 @@ static WORD_AUTHE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTHET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHET_CHILDREN),
+static WORD_AUTHET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHET_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("henticate"),
         dictgen::InsensitiveStr::Ascii("henticated"),
@@ -213462,12 +213462,12 @@ pub static WORD_AUTHET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=11,
 };
 
-static WORD_AUTHER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHER_CHILDREN),
+static WORD_AUTHER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHER_CHILDREN),
     value: Some(&["author"]),
 };
 
-pub static WORD_AUTHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isation"),
         dictgen::InsensitiveStr::Ascii("ise"),
@@ -213487,12 +213487,12 @@ pub static WORD_AUTHER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=7,
 };
 
-static WORD_AUTHEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AUTHEN_CHILDREN),
+static WORD_AUTHEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AUTHEN_CHILDREN),
     value: None,
 };
 
-static WORD_AUTHEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AUTHEN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AUTHENA_NODE),
     None,
     Some(&WORD_AUTHENC_NODE),
@@ -213521,12 +213521,12 @@ static WORD_AUTHEN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AUTHENT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENT_CHILDREN),
+static WORD_AUTHENT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -213584,12 +213584,12 @@ pub static WORD_AUTHENT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=9,
 };
 
-static WORD_AUTHENR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENR_CHILDREN),
+static WORD_AUTHENR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icate"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -213611,12 +213611,12 @@ pub static WORD_AUTHENR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=7,
 };
 
-static WORD_AUTHENI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENI_CHILDREN),
+static WORD_AUTHENI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cae"),
         dictgen::InsensitiveStr::Ascii("caed"),
@@ -213694,12 +213694,12 @@ pub static WORD_AUTHENI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=8,
 };
 
-static WORD_AUTHENF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENF_CHILDREN),
+static WORD_AUTHENF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENF_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -213721,12 +213721,12 @@ pub static WORD_AUTHENF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 2..=4,
 };
 
-static WORD_AUTHENE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENE_CHILDREN),
+static WORD_AUTHENE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nticate"),
         dictgen::InsensitiveStr::Ascii("nticated"),
@@ -213748,12 +213748,12 @@ pub static WORD_AUTHENE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 7..=9,
 };
 
-static WORD_AUTHEND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHEND_CHILDREN),
+static WORD_AUTHEND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHEND_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHEND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icate"),
         dictgen::InsensitiveStr::Ascii("icated"),
@@ -213775,12 +213775,12 @@ pub static WORD_AUTHEND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 5..=7,
 };
 
-static WORD_AUTHENC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENC_CHILDREN),
+static WORD_AUTHENC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -213846,12 +213846,12 @@ pub static WORD_AUTHENC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 3..=8,
 };
 
-static WORD_AUTHENA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENA_CHILDREN),
+static WORD_AUTHENA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHENA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHENA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ticate"),
         dictgen::InsensitiveStr::Ascii("ticated"),
@@ -213873,12 +213873,12 @@ pub static WORD_AUTHENA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTab
     range: 6..=8,
 };
 
-static WORD_AUTHEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTHEC_CHILDREN),
+static WORD_AUTHEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTHEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTHEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -213900,12 +213900,12 @@ pub static WORD_AUTHEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=5,
 };
 
-static WORD_AUTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTE_CHILDREN),
+static WORD_AUTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nticate"),
         dictgen::InsensitiveStr::Ascii("nticated"),
@@ -213929,23 +213929,23 @@ pub static WORD_AUTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=10,
 };
 
-static WORD_AUTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTC_CHILDREN),
+static WORD_AUTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("omplete")],
     values: &[&["autocomplete"]],
     range: 7..=7,
 };
 
-static WORD_AUTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUTA_CHILDREN),
+static WORD_AUTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("save"),
         dictgen::InsensitiveStr::Ascii("saves"),
@@ -213954,12 +213954,12 @@ pub static WORD_AUTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_AUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUS_CHILDREN),
+static WORD_AUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sian"),
         dictgen::InsensitiveStr::Ascii("tair"),
@@ -214027,23 +214027,23 @@ pub static WORD_AUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_AUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUR_CHILDREN),
+static WORD_AUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("omated")],
     values: &[&["automated"]],
     range: 6..=6,
 };
 
-static WORD_AUO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUO_CHILDREN),
+static WORD_AUO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("spacing"),
         dictgen::InsensitiveStr::Ascii("t"),
@@ -214063,12 +214063,12 @@ pub static WORD_AUO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_AUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUN_CHILDREN),
+static WORD_AUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thenticate"),
         dictgen::InsensitiveStr::Ascii("thenticated"),
@@ -214090,12 +214090,12 @@ pub static WORD_AUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 10..=12,
 };
 
-static WORD_AUI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUI_CHILDREN),
+static WORD_AUI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dobook"),
         dictgen::InsensitiveStr::Ascii("dobooks"),
@@ -214104,12 +214104,12 @@ pub static WORD_AUI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_AUH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUH_CHILDREN),
+static WORD_AUH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUH_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tenticate"),
         dictgen::InsensitiveStr::Ascii("tentication"),
@@ -214125,12 +214125,12 @@ pub static WORD_AUH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_AUG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUG_CHILDREN),
+static WORD_AUG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("est"),
         dictgen::InsensitiveStr::Ascii("mnet"),
@@ -214162,23 +214162,23 @@ pub static WORD_AUG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_AUF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUF_CHILDREN),
+static WORD_AUF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUF_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["after"]],
     range: 3..=3,
 };
 
-static WORD_AUD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUD_CHILDREN),
+static WORD_AUD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUD_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actiy"),
         dictgen::InsensitiveStr::Ascii("bile"),
@@ -214218,12 +214218,12 @@ pub static WORD_AUD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_AUC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AUC_CHILDREN),
+static WORD_AUC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AUC_CHILDREN),
     value: None,
 };
 
-pub static WORD_AUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AUC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cess"),
         dictgen::InsensitiveStr::Ascii("cessive"),
@@ -214241,12 +214241,12 @@ pub static WORD_AUC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_AT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AT_CHILDREN),
+static WORD_AT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AT_CHILDREN),
     value: None,
 };
 
-static WORD_AT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ATA_NODE),
     None,
     Some(&WORD_ATC_NODE),
@@ -214275,12 +214275,12 @@ static WORD_AT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ATU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATU_CHILDREN),
+static WORD_ATU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("henticate"),
         dictgen::InsensitiveStr::Ascii("henticated"),
@@ -214302,12 +214302,12 @@ pub static WORD_ATU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=11,
 };
 
-static WORD_ATT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ATT_CHILDREN),
+static WORD_ATT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ATT_CHILDREN),
     value: None,
 };
 
-static WORD_ATT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ATT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ATTA_NODE),
     None,
     Some(&WORD_ATTC_NODE),
@@ -214336,12 +214336,12 @@ static WORD_ATT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ATTT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTT_CHILDREN),
+static WORD_ATTT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ached"),
         dictgen::InsensitiveStr::Ascii("ack"),
@@ -214359,12 +214359,12 @@ pub static WORD_ATTT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ATTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ATTR_CHILDREN),
+static WORD_ATTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ATTR_CHILDREN),
     value: None,
 };
 
-static WORD_ATTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ATTR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ATTRA_NODE),
     Some(&WORD_ATTRB_NODE),
     None,
@@ -214393,12 +214393,12 @@ static WORD_ATTR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ATTRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRU_CHILDREN),
+static WORD_ATTRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bite"),
         dictgen::InsensitiveStr::Ascii("bites"),
@@ -214430,12 +214430,12 @@ pub static WORD_ATTRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ATTRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRR_CHILDREN),
+static WORD_ATTRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ibute"),
         dictgen::InsensitiveStr::Ascii("ibuted"),
@@ -214451,23 +214451,23 @@ pub static WORD_ATTRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ATTRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRO_CHILDREN),
+static WORD_ATTRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cities")],
     values: &[&["atrocities"]],
     range: 6..=6,
 };
 
-static WORD_ATTRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRI_CHILDREN),
+static WORD_ATTRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bbute"),
         dictgen::InsensitiveStr::Ascii("biute"),
@@ -214587,12 +214587,12 @@ pub static WORD_ATTRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ATTRB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRB_CHILDREN),
+static WORD_ATTRB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iute"),
         dictgen::InsensitiveStr::Ascii("ute"),
@@ -214612,12 +214612,12 @@ pub static WORD_ATTRB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ATTRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTRA_CHILDREN),
+static WORD_ATTRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cs"),
         dictgen::InsensitiveStr::Ascii("cters"),
@@ -214643,12 +214643,12 @@ pub static WORD_ATTRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ATTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTO_CHILDREN),
+static WORD_ATTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rnies"),
         dictgen::InsensitiveStr::Ascii("sencond"),
@@ -214658,23 +214658,23 @@ pub static WORD_ATTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ATTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTN_CHILDREN),
+static WORD_ATTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("etion")],
     values: &[&["attention"]],
     range: 5..=5,
 };
 
-static WORD_ATTM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTM_CHILDREN),
+static WORD_ATTM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ept"),
         dictgen::InsensitiveStr::Ascii("epted"),
@@ -214692,12 +214692,12 @@ pub static WORD_ATTM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ATTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTI_CHILDREN),
+static WORD_ATTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bures"),
         dictgen::InsensitiveStr::Ascii("bute"),
@@ -214731,12 +214731,12 @@ pub static WORD_ATTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ATTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTE_CHILDREN),
+static WORD_ATTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ched"),
         dictgen::InsensitiveStr::Ascii("ment"),
@@ -214830,12 +214830,12 @@ pub static WORD_ATTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ATTC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTC_CHILDREN),
+static WORD_ATTC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahed"),
         dictgen::InsensitiveStr::Ascii("h"),
@@ -214855,12 +214855,12 @@ pub static WORD_ATTC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ATTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATTA_CHILDREN),
+static WORD_ATTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ached"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -214944,12 +214944,12 @@ pub static WORD_ATTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ATR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATR_CHILDREN),
+static WORD_ATR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("active"),
@@ -214999,23 +214999,23 @@ pub static WORD_ATR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ATQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATQ_CHILDREN),
+static WORD_ATQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("uired")],
     values: &[&["acquired"]],
     range: 5..=5,
 };
 
-static WORD_ATO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATO_CHILDREN),
+static WORD_ATO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matically"),
         dictgen::InsensitiveStr::Ascii("mical"),
@@ -215053,12 +215053,12 @@ pub static WORD_ATO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ATM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATM_CHILDREN),
+static WORD_ATM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oic"),
         dictgen::InsensitiveStr::Ascii("oically"),
@@ -215090,12 +215090,12 @@ pub static WORD_ATM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ATL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATL_CHILDREN),
+static WORD_ATL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("antc"),
         dictgen::InsensitiveStr::Ascii("antia"),
@@ -215113,12 +215113,12 @@ pub static WORD_ATL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ATI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATI_CHILDREN),
+static WORD_ATI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("facts"),
         dictgen::InsensitiveStr::Ascii("ttude"),
@@ -215134,12 +215134,12 @@ pub static WORD_ATI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_ATH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATH_CHILDREN),
+static WORD_ATH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eisim"),
         dictgen::InsensitiveStr::Ascii("eistc"),
@@ -215221,12 +215221,12 @@ pub static WORD_ATH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ATE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATE_CHILDREN),
+static WORD_ATE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("last"),
         dictgen::InsensitiveStr::Ascii("mpt"),
@@ -215260,23 +215260,23 @@ pub static WORD_ATE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ATC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATC_CHILDREN),
+static WORD_ATC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ualy")],
     values: &[&["actually"]],
     range: 4..=4,
 };
 
-static WORD_ATA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ATA_CHILDREN),
+static WORD_ATA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ATA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ATA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("ched"),
@@ -215314,12 +215314,12 @@ pub static WORD_ATA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_AS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AS_CHILDREN),
+static WORD_AS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AS_CHILDREN),
     value: None,
 };
 
-static WORD_AS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASA_NODE),
     Some(&WORD_ASB_NODE),
     Some(&WORD_ASC_NODE),
@@ -215348,12 +215348,12 @@ static WORD_AS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ASY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASY_CHILDREN),
+static WORD_ASY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chronize"),
         dictgen::InsensitiveStr::Ascii("chronized"),
@@ -215443,12 +215443,12 @@ pub static WORD_ASY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_ASW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASW_CHILDREN),
+static WORD_ASW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("er"),
@@ -215457,12 +215457,12 @@ pub static WORD_ASW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=3,
 };
 
-static WORD_ASU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASU_CHILDREN),
+static WORD_ASU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("do"),
         dictgen::InsensitiveStr::Ascii("me"),
@@ -215494,12 +215494,12 @@ pub static WORD_ASU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_AST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AST_CHILDREN),
+static WORD_AST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AST_CHILDREN),
     value: None,
 };
 
-pub static WORD_AST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arisk"),
         dictgen::InsensitiveStr::Ascii("arisks"),
@@ -215611,12 +215611,12 @@ pub static WORD_AST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ASS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ASS_CHILDREN),
+static WORD_ASS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ASS_CHILDREN),
     value: None,
 };
 
-static WORD_ASS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ASS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASSA_NODE),
     None,
     Some(&WORD_ASSC_NODE),
@@ -215645,12 +215645,12 @@ static WORD_ASS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ASSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSY_CHILDREN),
+static WORD_ASSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("metric"),
         dictgen::InsensitiveStr::Ascii("metrical"),
@@ -215692,12 +215692,12 @@ pub static WORD_ASSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ASSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSU_CHILDREN),
+static WORD_ASSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alt"),
         dictgen::InsensitiveStr::Ascii("alted"),
@@ -215819,12 +215819,12 @@ pub static WORD_ASSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_ASSS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSS_CHILDREN),
+static WORD_ASSS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asin"),
         dictgen::InsensitiveStr::Ascii("asins"),
@@ -215868,12 +215868,12 @@ pub static WORD_ASSS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ASSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ASSO_CHILDREN),
+static WORD_ASSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ASSO_CHILDREN),
     value: None,
 };
 
-static WORD_ASSO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ASSO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASSOA_NODE),
     None,
     Some(&WORD_ASSOC_NODE),
@@ -215902,12 +215902,12 @@ static WORD_ASSO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASSOZ_NODE),
 ];
 
-static WORD_ASSOZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOZ_CHILDREN),
+static WORD_ASSOZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iated"),
         dictgen::InsensitiveStr::Ascii("iation"),
@@ -215916,12 +215916,12 @@ pub static WORD_ASSOZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_ASSOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOT_CHILDREN),
+static WORD_ASSOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iated"),
         dictgen::InsensitiveStr::Ascii("iation"),
@@ -215931,12 +215931,12 @@ pub static WORD_ASSOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ASSOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOS_CHILDREN),
+static WORD_ASSOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciate"),
         dictgen::InsensitiveStr::Ascii("ciated"),
@@ -215974,23 +215974,23 @@ pub static WORD_ASSOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_ASSOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOM_CHILDREN),
+static WORD_ASSOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ption")],
     values: &[&["assumption"]],
     range: 5..=5,
 };
 
-static WORD_ASSOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOI_CHILDREN),
+static WORD_ASSOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("cate"),
@@ -216014,12 +216014,12 @@ pub static WORD_ASSOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ASSOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOC_CHILDREN),
+static WORD_ASSOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aited"),
         dictgen::InsensitiveStr::Ascii("aites"),
@@ -216129,12 +216129,12 @@ pub static WORD_ASSOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ASSOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSOA_CHILDREN),
+static WORD_ASSOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -216156,23 +216156,23 @@ pub static WORD_ASSOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ASSN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSN_CHILDREN),
+static WORD_ASSN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["assange"]],
     range: 3..=3,
 };
 
-static WORD_ASSM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSM_CHILDREN),
+static WORD_ASSM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("bler"),
@@ -216214,12 +216214,12 @@ pub static WORD_ASSM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_ASSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ASSI_CHILDREN),
+static WORD_ASSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ASSI_CHILDREN),
     value: None,
 };
 
-static WORD_ASSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ASSI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ASSIA_NODE),
     None,
     Some(&WORD_ASSIC_NODE),
@@ -216248,12 +216248,12 @@ static WORD_ASSI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ASSIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIT_CHILDREN),
+static WORD_ASSIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIT_CHILDREN),
     value: Some(&["assist"]),
 };
 
-pub static WORD_ASSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ant"),
@@ -216271,12 +216271,12 @@ pub static WORD_ASSIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ASSIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIS_CHILDREN),
+static WORD_ASSIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ance"),
         dictgen::InsensitiveStr::Ascii("ant"),
@@ -216328,12 +216328,12 @@ pub static WORD_ASSIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ASSIO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIO_CHILDREN),
+static WORD_ASSIO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -216361,12 +216361,12 @@ pub static WORD_ASSIO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ASSIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIN_CHILDREN),
+static WORD_ASSIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -216396,12 +216396,12 @@ pub static WORD_ASSIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ASSIM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIM_CHILDREN),
+static WORD_ASSIM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -216437,12 +216437,12 @@ pub static WORD_ASSIM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ASSIH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIH_CHILDREN),
+static WORD_ASSIH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nment"),
         dictgen::InsensitiveStr::Ascii("nments"),
@@ -216451,12 +216451,12 @@ pub static WORD_ASSIH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_ASSIG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIG_CHILDREN),
+static WORD_ASSIG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("end"),
@@ -216544,23 +216544,23 @@ pub static WORD_ASSIG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ASSID_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSID_CHILDREN),
+static WORD_ASSID_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSID_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSID_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSID_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["aside"]],
     range: 1..=1,
 };
 
-static WORD_ASSIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIC_CHILDREN),
+static WORD_ASSIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -216592,23 +216592,23 @@ pub static WORD_ASSIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ASSIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSIA_CHILDREN),
+static WORD_ASSIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tnce")],
     values: &[&["assistance"]],
     range: 4..=4,
 };
 
-static WORD_ASSH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSH_CHILDREN),
+static WORD_ASSH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ates"),
         dictgen::InsensitiveStr::Ascii("atts"),
@@ -216617,12 +216617,12 @@ pub static WORD_ASSH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ASSG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSG_CHILDREN),
+static WORD_ASSG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("in"),
         dictgen::InsensitiveStr::Ascii("ined"),
@@ -216642,12 +216642,12 @@ pub static WORD_ASSG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ASSF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSF_CHILDREN),
+static WORD_ASSF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alt"),
         dictgen::InsensitiveStr::Ascii("alted"),
@@ -216658,12 +216658,12 @@ pub static WORD_ASSF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ASSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSE_CHILDREN),
+static WORD_ASSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bly"),
         dictgen::InsensitiveStr::Ascii("bmly"),
@@ -216767,12 +216767,12 @@ pub static WORD_ASSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_ASSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSC_CHILDREN),
+static WORD_ASSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciated"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -216792,12 +216792,12 @@ pub static WORD_ASSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ASSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASSA_CHILDREN),
+static WORD_ASSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gne"),
         dictgen::InsensitiveStr::Ascii("mble"),
@@ -216857,23 +216857,23 @@ pub static WORD_ASSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ASR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASR_CHILDREN),
+static WORD_ASR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("onist")],
     values: &[&["arsonist"]],
     range: 5..=5,
 };
 
-static WORD_ASP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASP_CHILDREN),
+static WORD_ASP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahlt"),
         dictgen::InsensitiveStr::Ascii("ected"),
@@ -216905,12 +216905,12 @@ pub static WORD_ASP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ASO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASO_CHILDREN),
+static WORD_ASO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASO_CHILDREN),
     value: Some(&["also"]),
 };
 
-pub static WORD_ASO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ciated"),
         dictgen::InsensitiveStr::Ascii("lute"),
@@ -216920,12 +216920,12 @@ pub static WORD_ASO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ASN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASN_CHILDREN),
+static WORD_ASN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("wer"),
@@ -216951,12 +216951,12 @@ pub static WORD_ASN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ASL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASL_CHILDREN),
+static WORD_ASL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ias"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -216965,12 +216965,12 @@ pub static WORD_ASL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_ASK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASK_CHILDREN),
+static WORD_ASK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -216981,12 +216981,12 @@ pub static WORD_ASK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ASI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASI_CHILDREN),
+static WORD_ASI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gn"),
         dictgen::InsensitiveStr::Ascii("gned"),
@@ -217034,23 +217034,23 @@ pub static WORD_ASI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ASH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASH_CHILDREN),
+static WORD_ASH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("palt")],
     values: &[&["asphalt"]],
     range: 4..=4,
 };
 
-static WORD_ASE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASE_CHILDREN),
+static WORD_ASE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mble"),
         dictgen::InsensitiveStr::Ascii("mbled"),
@@ -217120,12 +217120,12 @@ pub static WORD_ASE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_ASD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASD_CHILDREN),
+static WORD_ASD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ignment"),
         dictgen::InsensitiveStr::Ascii("ignments"),
@@ -217134,12 +217134,12 @@ pub static WORD_ASD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 7..=8,
 };
 
-static WORD_ASC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASC_CHILDREN),
+static WORD_ASC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("conciated"),
         dictgen::InsensitiveStr::Ascii("eding"),
@@ -217165,12 +217165,12 @@ pub static WORD_ASC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ASB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASB_CHILDREN),
+static WORD_ASB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("estoast"),
         dictgen::InsensitiveStr::Ascii("estoes"),
@@ -217216,12 +217216,12 @@ pub static WORD_ASB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_ASA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ASA_CHILDREN),
+static WORD_ASA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ASA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ASA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("in"),
@@ -217231,12 +217231,12 @@ pub static WORD_ASA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_AR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AR_CHILDREN),
+static WORD_AR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AR_CHILDREN),
     value: None,
 };
 
-static WORD_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARA_NODE),
     Some(&WORD_ARB_NODE),
     Some(&WORD_ARC_NODE),
@@ -217265,23 +217265,23 @@ static WORD_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARV_CHILDREN),
+static WORD_ARV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("g")],
     values: &[&["argv"]],
     range: 1..=1,
 };
 
-static WORD_ARU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARU_CHILDREN),
+static WORD_ARU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gable"),
         dictgen::InsensitiveStr::Ascii("gably"),
@@ -217309,12 +217309,12 @@ pub static WORD_ARU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_ART_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ART_CHILDREN),
+static WORD_ART_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ART_CHILDREN),
     value: None,
 };
 
-pub static WORD_ART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ART_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cile"),
         dictgen::InsensitiveStr::Ascii("cle"),
@@ -217436,12 +217436,12 @@ pub static WORD_ART_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ARS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARS_CHILDREN),
+static WORD_ARS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enaal"),
         dictgen::InsensitiveStr::Ascii("neal"),
@@ -217451,12 +217451,12 @@ pub static WORD_ARS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=5,
 };
 
-static WORD_ARR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARR_CHILDREN),
+static WORD_ARR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARR_CHILDREN),
     value: None,
 };
 
-static WORD_ARR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARRA_NODE),
     None,
     None,
@@ -217485,12 +217485,12 @@ static WORD_ARR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARRY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRY_CHILDREN),
+static WORD_ARRY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRY_CHILDREN),
     value: Some(&["array", "carry"]),
 };
 
-pub static WORD_ARRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("as"),
@@ -217500,23 +217500,23 @@ pub static WORD_ARRY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_ARRT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRT_CHILDREN),
+static WORD_ARRT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ibute")],
     values: &[&["attribute"]],
     range: 5..=5,
 };
 
-static WORD_ARRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRR_CHILDREN),
+static WORD_ARRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -217534,12 +217534,12 @@ pub static WORD_ARRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ARRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRO_CHILDREN),
+static WORD_ARRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRO_CHILDREN),
     value: Some(&["arrow"]),
 };
 
-pub static WORD_ARRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("und"),
@@ -217548,23 +217548,23 @@ pub static WORD_ARRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_ARRN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRN_CHILDREN),
+static WORD_ARRN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("age")],
     values: &[&["arrange"]],
     range: 3..=3,
 };
 
-static WORD_ARRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRI_CHILDREN),
+static WORD_ARRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("se"),
         dictgen::InsensitiveStr::Ascii("ses"),
@@ -217582,12 +217582,12 @@ pub static WORD_ARRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ARRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRE_CHILDREN),
+static WORD_ARRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRE_CHILDREN),
     value: Some(&["are"]),
 };
 
-pub static WORD_ARRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("nged"),
@@ -217609,12 +217609,12 @@ pub static WORD_ARRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ARRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARRA_CHILDREN),
+static WORD_ARRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ge"),
@@ -217732,12 +217732,12 @@ pub static WORD_ARRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ARQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARQ_CHILDREN),
+static WORD_ARQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uitecture"),
         dictgen::InsensitiveStr::Ascii("uitectures"),
@@ -217746,12 +217746,12 @@ pub static WORD_ARQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=10,
 };
 
-static WORD_ARP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARP_CHILDREN),
+static WORD_ARP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anoid"),
         dictgen::InsensitiveStr::Ascii("atheid"),
@@ -217761,12 +217761,12 @@ pub static WORD_ARP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_ARO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARO_CHILDREN),
+static WORD_ARO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ara"),
         dictgen::InsensitiveStr::Ascii("aras"),
@@ -217800,12 +217800,12 @@ pub static WORD_ARO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ARM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARM_CHILDREN),
+static WORD_ARM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agaddon"),
         dictgen::InsensitiveStr::Ascii("ageddan"),
@@ -217865,12 +217865,12 @@ pub static WORD_ARM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ARL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARL_CHILDREN),
+static WORD_ARL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eady"),
         dictgen::InsensitiveStr::Ascii("ighty"),
@@ -217888,23 +217888,23 @@ pub static WORD_ARL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ARK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARK_CHILDREN),
+static WORD_ARK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("asnas")],
     values: &[&["arkansas"]],
     range: 5..=5,
 };
 
-static WORD_ARI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARI_CHILDREN),
+static WORD_ARI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bitary"),
         dictgen::InsensitiveStr::Ascii("biter"),
@@ -217998,12 +217998,12 @@ pub static WORD_ARI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ARH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARH_CHILDREN),
+static WORD_ARH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ive"),
         dictgen::InsensitiveStr::Ascii("ives"),
@@ -218013,12 +218013,12 @@ pub static WORD_ARH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_ARG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARG_CHILDREN),
+static WORD_ARG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ement"),
         dictgen::InsensitiveStr::Ascii("ements"),
@@ -218146,12 +218146,12 @@ pub static WORD_ARG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ARE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARE_CHILDREN),
+static WORD_ARE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ady"),
         dictgen::InsensitiveStr::Ascii("aldy"),
@@ -218179,12 +218179,12 @@ pub static WORD_ARE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ARD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARD_CHILDREN),
+static WORD_ARD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iuno"),
         dictgen::InsensitiveStr::Ascii("vark"),
@@ -218194,12 +218194,12 @@ pub static WORD_ARD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_ARC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARC_CHILDREN),
+static WORD_ARC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARC_CHILDREN),
     value: None,
 };
 
-static WORD_ARC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARCA_NODE),
     None,
     None,
@@ -218228,45 +218228,45 @@ static WORD_ARC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARCY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCY_CHILDREN),
+static WORD_ARCY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lic")],
     values: &[&["acrylic"]],
     range: 3..=3,
 };
 
-static WORD_ARCV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCV_CHILDREN),
+static WORD_ARCV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hive")],
     values: &[&["archive"]],
     range: 4..=4,
 };
 
-static WORD_ARCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCT_CHILDREN),
+static WORD_ARCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("icle")],
     values: &[&["article"]],
     range: 4..=4,
 };
 
-static WORD_ARCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCI_CHILDREN),
+static WORD_ARCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("techture"),
         dictgen::InsensitiveStr::Ascii("tecture"),
@@ -218290,12 +218290,12 @@ pub static WORD_ARCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ARCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARCH_CHILDREN),
+static WORD_ARCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARCH_CHILDREN),
     value: None,
 };
 
-static WORD_ARCH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARCH_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARCHA_NODE),
     None,
     None,
@@ -218324,23 +218324,23 @@ static WORD_ARCH_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARCHY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHY_CHILDREN),
+static WORD_ARCHY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("types")],
     values: &[&["archetypes"]],
     range: 5..=5,
 };
 
-static WORD_ARCHV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHV_CHILDREN),
+static WORD_ARCHV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ie"),
@@ -218351,12 +218351,12 @@ pub static WORD_ARCHV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_ARCHT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHT_CHILDREN),
+static WORD_ARCHT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecture"),
         dictgen::InsensitiveStr::Ascii("ectures"),
@@ -218382,12 +218382,12 @@ pub static WORD_ARCHT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ARCHO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHO_CHILDREN),
+static WORD_ARCHO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("ve"),
@@ -218396,12 +218396,12 @@ pub static WORD_ARCHO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_ARCHI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHI_CHILDREN),
+static WORD_ARCHI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ac"),
         dictgen::InsensitiveStr::Ascii("ctect"),
@@ -218517,12 +218517,12 @@ pub static WORD_ARCHI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_ARCHE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHE_CHILDREN),
+static WORD_ARCHE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aologist"),
         dictgen::InsensitiveStr::Ascii("aologists"),
@@ -218560,12 +218560,12 @@ pub static WORD_ARCHE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_ARCHA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCHA_CHILDREN),
+static WORD_ARCHA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCHA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCHA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elogical"),
         dictgen::InsensitiveStr::Ascii("elogists"),
@@ -218587,12 +218587,12 @@ pub static WORD_ARCHA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ARCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCE_CHILDREN),
+static WORD_ARCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("htype"),
         dictgen::InsensitiveStr::Ascii("htypes"),
@@ -218601,12 +218601,12 @@ pub static WORD_ARCE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_ARCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARCA_CHILDREN),
+static WORD_ARCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("heology"),
         dictgen::InsensitiveStr::Ascii("hic"),
@@ -218615,12 +218615,12 @@ pub static WORD_ARCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ARB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARB_CHILDREN),
+static WORD_ARB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARB_CHILDREN),
     value: None,
 };
 
-static WORD_ARB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARBA_NODE),
     None,
     None,
@@ -218649,12 +218649,12 @@ static WORD_ARB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARBU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBU_CHILDREN),
+static WORD_ARBU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("trarily"),
         dictgen::InsensitiveStr::Ascii("trary"),
@@ -218663,12 +218663,12 @@ pub static WORD_ARBU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ARBT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBT_CHILDREN),
+static WORD_ARBT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irarily"),
         dictgen::InsensitiveStr::Ascii("irary"),
@@ -218684,12 +218684,12 @@ pub static WORD_ARBT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ARBR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBR_CHILDREN),
+static WORD_ARBR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itarily"),
         dictgen::InsensitiveStr::Ascii("itary"),
@@ -218709,12 +218709,12 @@ pub static WORD_ARBR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=8,
 };
 
-static WORD_ARBO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBO_CHILDREN),
+static WORD_ARBO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rt"),
         dictgen::InsensitiveStr::Ascii("rted"),
@@ -218725,12 +218725,12 @@ pub static WORD_ARBO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ARBI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ARBI_CHILDREN),
+static WORD_ARBI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ARBI_CHILDREN),
     value: None,
 };
 
-static WORD_ARBI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ARBI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ARBIA_NODE),
     Some(&WORD_ARBIB_NODE),
     None,
@@ -218759,12 +218759,12 @@ static WORD_ARBI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ARBIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBIT_CHILDREN),
+static WORD_ARBIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arary"),
         dictgen::InsensitiveStr::Ascii("arily"),
@@ -218894,12 +218894,12 @@ pub static WORD_ARBIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ARBIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBIR_CHILDREN),
+static WORD_ARBIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arily"),
         dictgen::InsensitiveStr::Ascii("ary"),
@@ -218923,12 +218923,12 @@ pub static WORD_ARBIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ARBII_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBII_CHILDREN),
+static WORD_ARBII_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBII_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBII_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("trarily"),
         dictgen::InsensitiveStr::Ascii("trary"),
@@ -218937,12 +218937,12 @@ pub static WORD_ARBII_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ARBIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBIB_CHILDREN),
+static WORD_ARBIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tarily"),
         dictgen::InsensitiveStr::Ascii("tary"),
@@ -218958,12 +218958,12 @@ pub static WORD_ARBIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ARBIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBIA_CHILDREN),
+static WORD_ARBIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("traily"),
         dictgen::InsensitiveStr::Ascii("tray"),
@@ -218972,23 +218972,23 @@ pub static WORD_ARBIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ARBA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARBA_CHILDREN),
+static WORD_ARBA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARBA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARBA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARBA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("trary")],
     values: &[&["arbitrary"]],
     range: 5..=5,
 };
 
-static WORD_ARA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ARA_CHILDREN),
+static WORD_ARA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ARA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ARA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cnid"),
         dictgen::InsensitiveStr::Ascii("cnids"),
@@ -219018,12 +219018,12 @@ pub static WORD_ARA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_AQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AQ_CHILDREN),
+static WORD_AQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_AQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ain"),
         dictgen::InsensitiveStr::Ascii("aurium"),
@@ -219105,12 +219105,12 @@ pub static WORD_AQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_AP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AP_CHILDREN),
+static WORD_AP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AP_CHILDREN),
     value: None,
 };
 
-static WORD_AP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APA_NODE),
     None,
     None,
@@ -219139,12 +219139,12 @@ static WORD_AP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APY_CHILDREN),
+static WORD_APY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APY_CHILDREN),
     value: None,
 };
 
-pub static WORD_APY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oon"),
         dictgen::InsensitiveStr::Ascii("ooned"),
@@ -219155,23 +219155,23 @@ pub static WORD_APY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_APT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APT_CHILDREN),
+static WORD_APT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APT_CHILDREN),
     value: None,
 };
 
-pub static WORD_APT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("itudine")],
     values: &[&["aptitude"]],
     range: 7..=7,
 };
 
-static WORD_APS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APS_CHILDREN),
+static WORD_APS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APS_CHILDREN),
     value: None,
 };
 
-pub static WORD_APS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aragus"),
         dictgen::InsensitiveStr::Ascii("ects"),
@@ -219195,12 +219195,12 @@ pub static WORD_APS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_APR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APR_CHILDREN),
+static WORD_APR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APR_CHILDREN),
     value: None,
 };
 
-pub static WORD_APR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atheid"),
         dictgen::InsensitiveStr::Ascii("eciate"),
@@ -219312,12 +219312,12 @@ pub static WORD_APR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_APP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_APP_CHILDREN),
+static WORD_APP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_APP_CHILDREN),
     value: None,
 };
 
-static WORD_APP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_APP_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APPA_NODE),
     None,
     None,
@@ -219346,23 +219346,23 @@ static WORD_APP_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APPY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPY_CHILDREN),
+static WORD_APPY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPY_CHILDREN),
     value: Some(&["apply"]),
 };
 
-pub static WORD_APPY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ing")],
     values: &[&["applying"]],
     range: 3..=3,
 };
 
-static WORD_APPR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_APPR_CHILDREN),
+static WORD_APPR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_APPR_CHILDREN),
     value: None,
 };
 
-static WORD_APPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_APPR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APPRA_NODE),
     None,
     Some(&WORD_APPRC_NODE),
@@ -219391,12 +219391,12 @@ static WORD_APPR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APPRP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRP_CHILDREN),
+static WORD_APPRP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRP_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("riate"),
         dictgen::InsensitiveStr::Ascii("riately"),
@@ -219405,12 +219405,12 @@ pub static WORD_APPRP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_APPRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_APPRO_CHILDREN),
+static WORD_APPRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_APPRO_CHILDREN),
     value: None,
 };
 
-static WORD_APPRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_APPRO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APPROA_NODE),
     Some(&WORD_APPROB_NODE),
     Some(&WORD_APPROC_NODE),
@@ -219439,12 +219439,12 @@ static WORD_APPRO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APPROX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROX_CHILDREN),
+static WORD_APPROX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROX_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amate"),
         dictgen::InsensitiveStr::Ascii("amately"),
@@ -219518,12 +219518,12 @@ pub static WORD_APPROX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=9,
 };
 
-static WORD_APPROV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROV_CHILDREN),
+static WORD_APPROV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROV_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("el"),
         dictgen::InsensitiveStr::Ascii("ement"),
@@ -219532,12 +219532,12 @@ pub static WORD_APPROV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=5,
 };
 
-static WORD_APPROU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROU_CHILDREN),
+static WORD_APPROU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROU_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("val"),
         dictgen::InsensitiveStr::Ascii("ve"),
@@ -219555,23 +219555,23 @@ pub static WORD_APPROU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_APPROS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROS_CHILDREN),
+static WORD_APPROS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROS_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("traphe")],
     values: &[&["apostrophe"]],
     range: 6..=6,
 };
 
-static WORD_APPROR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROR_CHILDREN),
+static WORD_APPROR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROR_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iately"),
@@ -219589,12 +219589,12 @@ pub static WORD_APPROR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=8,
 };
 
-static WORD_APPROP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROP_CHILDREN),
+static WORD_APPROP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROP_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aite"),
         dictgen::InsensitiveStr::Ascii("eriate"),
@@ -219686,12 +219686,12 @@ pub static WORD_APPROP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=11,
 };
 
-static WORD_APPROO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROO_CHILDREN),
+static WORD_APPROO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROO_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("priate"),
         dictgen::InsensitiveStr::Ascii("ximate"),
@@ -219711,23 +219711,23 @@ pub static WORD_APPROO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 6..=9,
 };
 
-static WORD_APPROM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROM_CHILDREN),
+static WORD_APPROM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROM_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ixation")],
     values: &[&["approximation"]],
     range: 7..=7,
 };
 
-static WORD_APPROI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROI_CHILDREN),
+static WORD_APPROI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROI_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("mation"),
@@ -219736,12 +219736,12 @@ pub static WORD_APPROI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=6,
 };
 
-static WORD_APPROC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROC_CHILDREN),
+static WORD_APPROC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROC_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("h"),
         dictgen::InsensitiveStr::Ascii("he"),
@@ -219759,23 +219759,23 @@ pub static WORD_APPROC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 1..=4,
 };
 
-static WORD_APPROB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROB_CHILDREN),
+static WORD_APPROB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROB_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iate")],
     values: &[&["appropriate"]],
     range: 4..=4,
 };
 
-static WORD_APPROA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPROA_CHILDREN),
+static WORD_APPROA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPROA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPROA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chs"),
         dictgen::InsensitiveStr::Ascii("cing"),
@@ -219785,12 +219785,12 @@ pub static WORD_APPROA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=4,
 };
 
-static WORD_APPRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRI_CHILDREN),
+static WORD_APPRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cated"),
@@ -219862,12 +219862,12 @@ pub static WORD_APPRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_APPRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRE_CHILDREN),
+static WORD_APPRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aciate"),
         dictgen::InsensitiveStr::Ascii("aciated"),
@@ -219975,12 +219975,12 @@ pub static WORD_APPRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_APPRC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRC_CHILDREN),
+static WORD_APPRC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRC_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -219989,12 +219989,12 @@ pub static WORD_APPRC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_APPRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPRA_CHILDREN),
+static WORD_APPRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ent"),
         dictgen::InsensitiveStr::Ascii("ently"),
@@ -220018,12 +220018,12 @@ pub static WORD_APPRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_APPP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPP_CHILDREN),
+static WORD_APPP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPP_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ear"),
         dictgen::InsensitiveStr::Ascii("ears"),
@@ -220053,12 +220053,12 @@ pub static WORD_APPP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_APPO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPO_CHILDREN),
+static WORD_APPO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPO_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inment"),
         dictgen::InsensitiveStr::Ascii("intement"),
@@ -220166,23 +220166,23 @@ pub static WORD_APPO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_APPN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPN_CHILDREN),
+static WORD_APPN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPN_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["append"]],
     range: 2..=2,
 };
 
-static WORD_APPL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_APPL_CHILDREN),
+static WORD_APPL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_APPL_CHILDREN),
     value: None,
 };
 
-static WORD_APPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_APPL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_APPLA_NODE),
     None,
     Some(&WORD_APPLC_NODE),
@@ -220211,12 +220211,12 @@ static WORD_APPL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_APPLY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLY_CHILDREN),
+static WORD_APPLY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLY_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("cable"),
@@ -220240,12 +220240,12 @@ pub static WORD_APPLY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_APPLU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLU_CHILDREN),
+static WORD_APPLU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLU_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("ase"),
@@ -220254,12 +220254,12 @@ pub static WORD_APPLU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_APPLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLO_CHILDREN),
+static WORD_APPLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLO_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gies"),
         dictgen::InsensitiveStr::Ascii("gize"),
@@ -220268,12 +220268,12 @@ pub static WORD_APPLO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_APPLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLL_CHILDREN),
+static WORD_APPLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLL_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("y"),
@@ -220282,12 +220282,12 @@ pub static WORD_APPLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_APPLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLI_CHILDREN),
+static WORD_APPLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("acable"),
@@ -220387,12 +220387,12 @@ pub static WORD_APPLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_APPLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLC_CHILDREN),
+static WORD_APPLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("ations"),
@@ -220408,12 +220408,12 @@ pub static WORD_APPLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_APPLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPLA_CHILDREN),
+static WORD_APPLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inces"),
         dictgen::InsensitiveStr::Ascii("udes"),
@@ -220424,12 +220424,12 @@ pub static WORD_APPLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_APPI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPI_CHILDREN),
+static WORD_APPI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPI_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cability"),
         dictgen::InsensitiveStr::Ascii("cable"),
@@ -220457,12 +220457,12 @@ pub static WORD_APPI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_APPE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPE_CHILDREN),
+static WORD_APPE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPE_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alling"),
         dictgen::InsensitiveStr::Ascii("araing"),
@@ -220584,12 +220584,12 @@ pub static WORD_APPE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_APPA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APPA_CHILDREN),
+static WORD_APPA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APPA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APPA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -220653,12 +220653,12 @@ pub static WORD_APPA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_APO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APO_CHILDREN),
+static WORD_APO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APO_CHILDREN),
     value: None,
 };
 
-pub static WORD_APO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("calipse"),
         dictgen::InsensitiveStr::Ascii("caliptic"),
@@ -220778,12 +220778,12 @@ pub static WORD_APO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_APL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APL_CHILDREN),
+static WORD_APL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APL_CHILDREN),
     value: None,
 };
 
-pub static WORD_APL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ha"),
         dictgen::InsensitiveStr::Ascii("habet"),
@@ -220841,12 +220841,12 @@ pub static WORD_APL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_API_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_API_CHILDREN),
+static WORD_API_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_API_CHILDREN),
     value: None,
 };
 
-pub static WORD_API_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_API_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("helion"),
         dictgen::InsensitiveStr::Ascii("helions"),
@@ -220856,23 +220856,23 @@ pub static WORD_API_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_APH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APH_CHILDREN),
+static WORD_APH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APH_CHILDREN),
     value: None,
 };
 
-pub static WORD_APH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("abetical")],
     values: &[&["alphabetical"]],
     range: 8..=8,
 };
 
-static WORD_APE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APE_CHILDREN),
+static WORD_APE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APE_CHILDREN),
     value: None,
 };
 
-pub static WORD_APE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("aled"),
@@ -220932,23 +220932,23 @@ pub static WORD_APE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_APD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APD_CHILDREN),
+static WORD_APD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APD_CHILDREN),
     value: None,
 };
 
-pub static WORD_APD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ated")],
     values: &[&["updated"]],
     range: 4..=4,
 };
 
-static WORD_APA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_APA_CHILDREN),
+static WORD_APA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_APA_CHILDREN),
     value: None,
 };
 
-pub static WORD_APA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_APA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ch"),
         dictgen::InsensitiveStr::Ascii("colypse"),
@@ -220998,12 +220998,12 @@ pub static WORD_APA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_AO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AO_CHILDREN),
+static WORD_AO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ache"),
         dictgen::InsensitiveStr::Ascii("but"),
@@ -221043,12 +221043,12 @@ pub static WORD_AO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=11,
 };
 
-static WORD_AN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AN_CHILDREN),
+static WORD_AN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AN_CHILDREN),
     value: None,
 };
 
-static WORD_AN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANA_NODE),
     Some(&WORD_ANB_NODE),
     Some(&WORD_ANC_NODE),
@@ -221077,12 +221077,12 @@ static WORD_AN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANY_CHILDREN),
+static WORD_ANY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("away"),
         dictgen::InsensitiveStr::Ascii("awy"),
@@ -221158,12 +221158,12 @@ pub static WORD_ANY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ANX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANX_CHILDREN),
+static WORD_ANX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANX_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eity"),
         dictgen::InsensitiveStr::Ascii("ios"),
@@ -221185,12 +221185,12 @@ pub static WORD_ANX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ANW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANW_CHILDREN),
+static WORD_ANW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ay"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -221220,12 +221220,12 @@ pub static WORD_ANW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ANU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANU_CHILDREN),
+static WORD_ANU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("alized"),
@@ -221261,12 +221261,12 @@ pub static WORD_ANU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ANT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANT_CHILDREN),
+static WORD_ANT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANT_CHILDREN),
     value: None,
 };
 
-static WORD_ANT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANTA_NODE),
     None,
     None,
@@ -221295,23 +221295,23 @@ static WORD_ANT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANTY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTY_CHILDREN),
+static WORD_ANTY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hing")],
     values: &[&["anything"]],
     range: 4..=4,
 };
 
-static WORD_ANTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTR_CHILDREN),
+static WORD_ANTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("actica"),
         dictgen::InsensitiveStr::Ascii("hopology"),
@@ -221331,12 +221331,12 @@ pub static WORD_ANTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ANTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTO_CHILDREN),
+static WORD_ANTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ganist"),
         dictgen::InsensitiveStr::Ascii("gonistic"),
@@ -221346,12 +221346,12 @@ pub static WORD_ANTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ANTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTI_CHILDREN),
+static WORD_ANTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alialised"),
         dictgen::InsensitiveStr::Ascii("alised"),
@@ -221445,12 +221445,12 @@ pub static WORD_ANTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=12,
 };
 
-static WORD_ANTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTH_CHILDREN),
+static WORD_ANTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ings"),
@@ -221474,12 +221474,12 @@ pub static WORD_ANTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=14,
 };
 
-static WORD_ANTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTE_CHILDREN),
+static WORD_ANTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cedant"),
         dictgen::InsensitiveStr::Ascii("ena"),
@@ -221499,12 +221499,12 @@ pub static WORD_ANTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ANTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANTA_CHILDREN),
+static WORD_ANTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ganist"),
         dictgen::InsensitiveStr::Ascii("ganistic"),
@@ -221540,12 +221540,12 @@ pub static WORD_ANTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_ANS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANS_CHILDREN),
+static WORD_ANS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alisation"),
         dictgen::InsensitiveStr::Ascii("alization"),
@@ -221599,12 +221599,12 @@ pub static WORD_ANS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_ANR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANR_CHILDREN),
+static WORD_ANR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("achist"),
         dictgen::InsensitiveStr::Ascii("oid"),
@@ -221613,12 +221613,12 @@ pub static WORD_ANR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_ANP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANP_CHILDREN),
+static WORD_ANP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atheater"),
         dictgen::InsensitiveStr::Ascii("atheaters"),
@@ -221648,12 +221648,12 @@ pub static WORD_ANP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=10,
 };
 
-static WORD_ANO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANO_CHILDREN),
+static WORD_ANO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANO_CHILDREN),
     value: None,
 };
 
-static WORD_ANO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -221682,12 +221682,12 @@ static WORD_ANO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOY_CHILDREN),
+static WORD_ANOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOY_CHILDREN),
     value: Some(&["annoy"]),
 };
 
-pub static WORD_ANOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -221707,12 +221707,12 @@ pub static WORD_ANOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ANOX_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOX_CHILDREN),
+static WORD_ANOX_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOX_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOX_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eria"),
         dictgen::InsensitiveStr::Ascii("eric"),
@@ -221721,12 +221721,12 @@ pub static WORD_ANOX_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ANOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOU_CHILDREN),
+static WORD_ANOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nce"),
         dictgen::InsensitiveStr::Ascii("nced"),
@@ -221746,12 +221746,12 @@ pub static WORD_ANOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ANOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOT_CHILDREN),
+static WORD_ANOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -221783,12 +221783,12 @@ pub static WORD_ANOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ANOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOR_CHILDREN),
+static WORD_ANOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eixa"),
         dictgen::InsensitiveStr::Ascii("exiac"),
@@ -221810,23 +221810,23 @@ pub static WORD_ANOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ANOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOP_CHILDREN),
+static WORD_ANOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ther")],
     values: &[&["another"]],
     range: 4..=4,
 };
 
-static WORD_ANON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANON_CHILDREN),
+static WORD_ANON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amously"),
         dictgen::InsensitiveStr::Ascii("imised"),
@@ -221886,12 +221886,12 @@ pub static WORD_ANON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ANOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOM_CHILDREN),
+static WORD_ANOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ally"),
         dictgen::InsensitiveStr::Ascii("isity"),
@@ -221915,12 +221915,12 @@ pub static WORD_ANOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ANOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOL_CHILDREN),
+static WORD_ANOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ogon"),
         dictgen::InsensitiveStr::Ascii("ogous"),
@@ -221929,12 +221929,12 @@ pub static WORD_ANOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_ANOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOH_CHILDREN),
+static WORD_ANOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -221943,12 +221943,12 @@ pub static WORD_ANOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_ANOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANOE_CHILDREN),
+static WORD_ANOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rxia"),
         dictgen::InsensitiveStr::Ascii("rxic"),
@@ -221957,12 +221957,12 @@ pub static WORD_ANOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ANN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANN_CHILDREN),
+static WORD_ANN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANN_CHILDREN),
     value: None,
 };
 
-static WORD_ANN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANN_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANNA_NODE),
     None,
     None,
@@ -221991,12 +221991,12 @@ static WORD_ANN_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANNY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNY_CHILDREN),
+static WORD_ANNY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oance"),
         dictgen::InsensitiveStr::Ascii("oingly"),
@@ -222005,12 +222005,12 @@ pub static WORD_ANNY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=6,
 };
 
-static WORD_ANNU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNU_CHILDREN),
+static WORD_ANNU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aly"),
         dictgen::InsensitiveStr::Ascii("ciators"),
@@ -222020,12 +222020,12 @@ pub static WORD_ANNU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ANNT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNT_CHILDREN),
+static WORD_ANNT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ations"),
         dictgen::InsensitiveStr::Ascii("enas"),
@@ -222035,12 +222035,12 @@ pub static WORD_ANNT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ANNO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANNO_CHILDREN),
+static WORD_ANNO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANNO_CHILDREN),
     value: None,
 };
 
-static WORD_ANNO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANNO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANNOA_NODE),
     None,
     None,
@@ -222069,12 +222069,12 @@ static WORD_ANNO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANNOY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOY_CHILDREN),
+static WORD_ANNOY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ences"),
@@ -222102,12 +222102,12 @@ pub static WORD_ANNOY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ANNOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOU_CHILDREN),
+static WORD_ANNOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -222173,12 +222173,12 @@ pub static WORD_ANNOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ANNOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOT_CHILDREN),
+static WORD_ANNOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aion"),
         dictgen::InsensitiveStr::Ascii("aions"),
@@ -222200,12 +222200,12 @@ pub static WORD_ANNOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ANNON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNON_CHILDREN),
+static WORD_ANNON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -222249,12 +222249,12 @@ pub static WORD_ANNON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ANNOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOI_CHILDREN),
+static WORD_ANNOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nt"),
         dictgen::InsensitiveStr::Ascii("nted"),
@@ -222265,34 +222265,34 @@ pub static WORD_ANNOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ANNOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNOA_CHILDREN),
+static WORD_ANNOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tion")],
     values: &[&["annotation"]],
     range: 4..=4,
 };
 
-static WORD_ANNN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNN_CHILDREN),
+static WORD_ANNN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ounce")],
     values: &[&["announce"]],
     range: 5..=5,
 };
 
-static WORD_ANNI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNI_CHILDREN),
+static WORD_ANNI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("halated"),
         dictgen::InsensitiveStr::Ascii("halition"),
@@ -222338,34 +222338,34 @@ pub static WORD_ANNI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ANNH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNH_CHILDREN),
+static WORD_ANNH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iliation")],
     values: &[&["annihilation"]],
     range: 8..=8,
 };
 
-static WORD_ANND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANND_CHILDREN),
+static WORD_ANND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANND_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ANNA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANNA_CHILDREN),
+static WORD_ANNA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANNA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANNA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("verseries"),
         dictgen::InsensitiveStr::Ascii("versery"),
@@ -222387,12 +222387,12 @@ pub static WORD_ANNA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ANM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANM_CHILDREN),
+static WORD_ANM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("esia"),
@@ -222402,12 +222402,12 @@ pub static WORD_ANM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_ANL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANL_CHILDREN),
+static WORD_ANL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ayses"),
         dictgen::InsensitiveStr::Ascii("aysis"),
@@ -222433,12 +222433,12 @@ pub static WORD_ANL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_ANK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANK_CHILDREN),
+static WORD_ANK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("shios"),
         dictgen::InsensitiveStr::Ascii("shiosly"),
@@ -222470,23 +222470,23 @@ pub static WORD_ANK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ANJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANJ_CHILDREN),
+static WORD_ANJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("anew")],
     values: &[&["ingenue"]],
     range: 4..=4,
 };
 
-static WORD_ANI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANI_CHILDREN),
+static WORD_ANI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("alated"),
@@ -222600,23 +222600,23 @@ pub static WORD_ANI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=13,
 };
 
-static WORD_ANH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANH_CHILDREN),
+static WORD_ANH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("oter")],
     values: &[&["another"]],
     range: 4..=4,
 };
 
-static WORD_ANG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANG_CHILDREN),
+static WORD_ANG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irly"),
         dictgen::InsensitiveStr::Ascii("luar"),
@@ -222668,23 +222668,23 @@ pub static WORD_ANG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ANF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANF_CHILDREN),
+static WORD_ANF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANF_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["and"]],
     range: 1..=1,
 };
 
-static WORD_ANE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANE_CHILDREN),
+static WORD_ANE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANE_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cdatally"),
         dictgen::InsensitiveStr::Ascii("cdotale"),
@@ -222752,12 +222752,12 @@ pub static WORD_ANE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_AND_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AND_CHILDREN),
+static WORD_AND_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AND_CHILDREN),
     value: None,
 };
 
-pub static WORD_AND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AND_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("elabra"),
@@ -222809,12 +222809,12 @@ pub static WORD_AND_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_ANC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANC_CHILDREN),
+static WORD_ANC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANC_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apsulate"),
         dictgen::InsensitiveStr::Ascii("apsulated"),
@@ -222872,23 +222872,23 @@ pub static WORD_ANC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=10,
 };
 
-static WORD_ANB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANB_CHILDREN),
+static WORD_ANB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["and"]],
     range: 1..=1,
 };
 
-static WORD_ANA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANA_CHILDREN),
+static WORD_ANA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANA_CHILDREN),
     value: None,
 };
 
-static WORD_ANA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANA_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_ANAC_NODE),
@@ -222917,12 +222917,12 @@ static WORD_ANA_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ANAY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAY_CHILDREN),
+static WORD_ANAY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lse"),
         dictgen::InsensitiveStr::Ascii("lsed"),
@@ -222968,12 +222968,12 @@ pub static WORD_ANAY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ANAR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAR_CHILDREN),
+static WORD_ANAR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chim"),
         dictgen::InsensitiveStr::Ascii("chisim"),
@@ -223013,34 +223013,34 @@ pub static WORD_ANAR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ANAO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAO_CHILDREN),
+static WORD_ANAO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lgue")],
     values: &[&["analogue"]],
     range: 4..=4,
 };
 
-static WORD_ANAN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAN_CHILDREN),
+static WORD_ANAN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("log")],
     values: &[&["analog"]],
     range: 3..=3,
 };
 
-static WORD_ANAL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ANAL_CHILDREN),
+static WORD_ANAL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ANAL_CHILDREN),
     value: None,
 };
 
-static WORD_ANAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ANAL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANALA_NODE),
     None,
     None,
@@ -223069,12 +223069,12 @@ static WORD_ANAL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_ANALZ_NODE),
 ];
 
-static WORD_ANALZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALZ_CHILDREN),
+static WORD_ANALZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ye"),
@@ -223096,12 +223096,12 @@ pub static WORD_ANALZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ANALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALY_CHILDREN),
+static WORD_ANALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -223183,23 +223183,23 @@ pub static WORD_ANALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ANALT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALT_CHILDREN),
+static WORD_ANALT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("yics")],
     values: &[&["analytics"]],
     range: 4..=4,
 };
 
-static WORD_ANALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALS_CHILDREN),
+static WORD_ANALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ye"),
         dictgen::InsensitiveStr::Ascii("yed"),
@@ -223227,12 +223227,12 @@ pub static WORD_ANALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ANALO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALO_CHILDREN),
+static WORD_ANALO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ge"),
         dictgen::InsensitiveStr::Ascii("geous"),
@@ -223256,12 +223256,12 @@ pub static WORD_ANALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ANALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALI_CHILDREN),
+static WORD_ANALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("g"),
         dictgen::InsensitiveStr::Ascii("se"),
@@ -223307,12 +223307,12 @@ pub static WORD_ANALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ANALG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALG_CHILDREN),
+static WORD_ANALG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oue"),
         dictgen::InsensitiveStr::Ascii("ous"),
@@ -223321,12 +223321,12 @@ pub static WORD_ANALG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_ANALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANALA_CHILDREN),
+static WORD_ANALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gous"),
         dictgen::InsensitiveStr::Ascii("gus"),
@@ -223337,45 +223337,45 @@ pub static WORD_ANALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ANAG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAG_CHILDREN),
+static WORD_ANAG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("er")],
     values: &[&["manager", "anger"]],
     range: 2..=2,
 };
 
-static WORD_ANAD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAD_CHILDREN),
+static WORD_ANAD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAD_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ANAD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ANAC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ANAC_CHILDREN),
+static WORD_ANAC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ANAC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ANAC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ANAC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hrist")],
     values: &[&["anarchist"]],
     range: 5..=5,
 };
 
-static WORD_AM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AM_CHILDREN),
+static WORD_AM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AM_CHILDREN),
     value: None,
 };
 
-static WORD_AM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AMA_NODE),
     Some(&WORD_AMB_NODE),
     None,
@@ -223404,12 +223404,12 @@ static WORD_AM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_AMZ_NODE),
 ];
 
-static WORD_AMZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMZ_CHILDREN),
+static WORD_AMZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aing"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -223418,12 +223418,12 @@ pub static WORD_AMZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_AMU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMU_CHILDREN),
+static WORD_AMU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blance"),
         dictgen::InsensitiveStr::Ascii("ch"),
@@ -223441,23 +223441,23 @@ pub static WORD_AMU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_AMT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMT_CHILDREN),
+static WORD_AMT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("heyst")],
     values: &[&["amethyst"]],
     range: 5..=5,
 };
 
-static WORD_AMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMR_CHILDREN),
+static WORD_AMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ageddon"),
         dictgen::InsensitiveStr::Ascii("chair"),
@@ -223475,12 +223475,12 @@ pub static WORD_AMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_AMP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMP_CHILDREN),
+static WORD_AMP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMP_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atheater"),
         dictgen::InsensitiveStr::Ascii("atheaters"),
@@ -223552,12 +223552,12 @@ pub static WORD_AMP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_AMO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMO_CHILDREN),
+static WORD_AMO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gnst"),
         dictgen::InsensitiveStr::Ascii("hetamines"),
@@ -223599,12 +223599,12 @@ pub static WORD_AMO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_AMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMN_CHILDREN),
+static WORD_AMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eisa"),
         dictgen::InsensitiveStr::Ascii("estry"),
@@ -223615,12 +223615,12 @@ pub static WORD_AMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_AMM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMM_CHILDREN),
+static WORD_AMM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMM_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("end"),
         dictgen::InsensitiveStr::Ascii("ended"),
@@ -223662,23 +223662,23 @@ pub static WORD_AMM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_AML_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AML_CHILDREN),
+static WORD_AML_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AML_CHILDREN),
     value: None,
 };
 
-pub static WORD_AML_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AML_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("pifier")],
     values: &[&["amplifier"]],
     range: 6..=6,
 };
 
-static WORD_AMK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMK_CHILDREN),
+static WORD_AMK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMK_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -223687,12 +223687,12 @@ pub static WORD_AMK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=3,
 };
 
-static WORD_AMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMI_CHILDREN),
+static WORD_AMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bguity"),
         dictgen::InsensitiveStr::Ascii("guity"),
@@ -223708,12 +223708,12 @@ pub static WORD_AMI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=6,
 };
 
-static WORD_AMG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMG_CHILDREN),
+static WORD_AMG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iguous"),
         dictgen::InsensitiveStr::Ascii("le"),
@@ -223723,12 +223723,12 @@ pub static WORD_AMG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_AME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AME_CHILDREN),
+static WORD_AME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AME_CHILDREN),
     value: None,
 };
 
-static WORD_AME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AME_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AMEA_NODE),
     None,
     None,
@@ -223757,34 +223757,34 @@ static WORD_AME_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AMEY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEY_CHILDREN),
+static WORD_AMEY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEY_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("thst")],
     values: &[&["amethyst"]],
     range: 4..=4,
 };
 
-static WORD_AMET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMET_CHILDREN),
+static WORD_AMET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMET_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hsyt")],
     values: &[&["amethyst"]],
     range: 4..=4,
 };
 
-static WORD_AMER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMER_CHILDREN),
+static WORD_AMER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMER_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cia"),
         dictgen::InsensitiveStr::Ascii("cian"),
@@ -223838,12 +223838,12 @@ pub static WORD_AMER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_AMEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEN_CHILDREN),
+static WORD_AMEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dement"),
         dictgen::InsensitiveStr::Ascii("dmant"),
@@ -223869,12 +223869,12 @@ pub static WORD_AMEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_AMEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEL_CHILDREN),
+static WORD_AMEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earate"),
         dictgen::InsensitiveStr::Ascii("earated"),
@@ -223894,12 +223894,12 @@ pub static WORD_AMEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=8,
 };
 
-static WORD_AMEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEE_CHILDREN),
+static WORD_AMEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("larate"),
         dictgen::InsensitiveStr::Ascii("larated"),
@@ -223931,12 +223931,12 @@ pub static WORD_AMEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=9,
 };
 
-static WORD_AMEA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMEA_CHILDREN),
+static WORD_AMEA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMEA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMEA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("learate"),
         dictgen::InsensitiveStr::Ascii("learated"),
@@ -223968,12 +223968,12 @@ pub static WORD_AMEA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=9,
 };
 
-static WORD_AMD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMD_CHILDREN),
+static WORD_AMD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMD_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("gput"),
@@ -223982,12 +223982,12 @@ pub static WORD_AMD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=4,
 };
 
-static WORD_AMB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMB_CHILDREN),
+static WORD_AMB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMB_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adexterous"),
         dictgen::InsensitiveStr::Ascii("adexterouseness"),
@@ -224065,12 +224065,12 @@ pub static WORD_AMB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=15,
 };
 
-static WORD_AMA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AMA_CHILDREN),
+static WORD_AMA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AMA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AMA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cing"),
         dictgen::InsensitiveStr::Ascii("cingly"),
@@ -224116,12 +224116,12 @@ pub static WORD_AMA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_AL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AL_CHILDREN),
+static WORD_AL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AL_CHILDREN),
     value: None,
 };
 
-static WORD_AL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ALA_NODE),
     Some(&WORD_ALB_NODE),
     Some(&WORD_ALC_NODE),
@@ -224150,23 +224150,23 @@ static WORD_AL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALY_CHILDREN),
+static WORD_ALY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ways")],
     values: &[&["always"]],
     range: 4..=4,
 };
 
-static WORD_ALW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALW_CHILDREN),
+static WORD_ALW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ais"),
         dictgen::InsensitiveStr::Ascii("ans"),
@@ -224200,12 +224200,12 @@ pub static WORD_ALW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ALV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALV_CHILDREN),
+static WORD_ALV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orithm"),
         dictgen::InsensitiveStr::Ascii("orithmic"),
@@ -224221,12 +224221,12 @@ pub static WORD_ALV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=12,
 };
 
-static WORD_ALU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALU_CHILDREN),
+static WORD_ALU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("minim"),
@@ -224246,12 +224246,12 @@ pub static WORD_ALU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ALT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALT_CHILDREN),
+static WORD_ALT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALT_CHILDREN),
     value: None,
 };
 
-static WORD_ALT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ALTA_NODE),
     None,
     None,
@@ -224280,12 +224280,12 @@ static WORD_ALT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTU_CHILDREN),
+static WORD_ALTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rism"),
         dictgen::InsensitiveStr::Ascii("ristic"),
@@ -224294,12 +224294,12 @@ pub static WORD_ALTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ALTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTR_CHILDREN),
+static WORD_ALTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eady"),
         dictgen::InsensitiveStr::Ascii("iusm"),
@@ -224327,12 +224327,12 @@ pub static WORD_ALTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_ALTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTO_CHILDREN),
+static WORD_ALTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gehter"),
         dictgen::InsensitiveStr::Ascii("gheter"),
@@ -224348,23 +224348,23 @@ pub static WORD_ALTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ALTN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTN_CHILDREN),
+static WORD_ALTN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("erately")],
     values: &[&["alternately"]],
     range: 7..=7,
 };
 
-static WORD_ALTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTI_CHILDREN),
+static WORD_ALTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tide"),
         dictgen::InsensitiveStr::Ascii("tute"),
@@ -224373,12 +224373,12 @@ pub static WORD_ALTI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ALTH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTH_CHILDREN),
+static WORD_ALTH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etes"),
         dictgen::InsensitiveStr::Ascii("etic"),
@@ -224414,12 +224414,12 @@ pub static WORD_ALTH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=12,
 };
 
-static WORD_ALTE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTE_CHILDREN),
+static WORD_ALTE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ast"),
         dictgen::InsensitiveStr::Ascii("nate"),
@@ -224551,12 +224551,12 @@ pub static WORD_ALTE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_ALTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALTA_CHILDREN),
+static WORD_ALTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nta"),
         dictgen::InsensitiveStr::Ascii("ntic"),
@@ -224566,12 +224566,12 @@ pub static WORD_ALTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ALS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALS_CHILDREN),
+static WORD_ALS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALS_CHILDREN),
     value: Some(&["also"]),
 };
 
-pub static WORD_ALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("most"),
@@ -224591,12 +224591,12 @@ pub static WORD_ALS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_ALR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALR_CHILDREN),
+static WORD_ALR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ady"),
         dictgen::InsensitiveStr::Ascii("aedy"),
@@ -224652,12 +224652,12 @@ pub static WORD_ALR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ALP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALP_CHILDREN),
+static WORD_ALP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abet"),
         dictgen::InsensitiveStr::Ascii("abetic"),
@@ -224703,12 +224703,12 @@ pub static WORD_ALP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_ALO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALO_CHILDREN),
+static WORD_ALO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALO_CHILDREN),
     value: Some(&["also"]),
 };
 
-pub static WORD_ALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("catable"),
@@ -224796,23 +224796,23 @@ pub static WORD_ALO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_ALN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALN_CHILDREN),
+static WORD_ALN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("terating")],
     values: &[&["alternating"]],
     range: 8..=8,
 };
 
-static WORD_ALM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALM_CHILDREN),
+static WORD_ALM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aost"),
         dictgen::InsensitiveStr::Ascii("ightly"),
@@ -224834,12 +224834,12 @@ pub static WORD_ALM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=6,
 };
 
-static WORD_ALL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALL_CHILDREN),
+static WORD_ALL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALL_CHILDREN),
     value: None,
 };
 
-static WORD_ALL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALL_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ALLA_NODE),
     None,
     Some(&WORD_ALLC_NODE),
@@ -224868,12 +224868,12 @@ static WORD_ALL_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALLW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLW_CHILDREN),
+static WORD_ALLW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ays"),
         dictgen::InsensitiveStr::Ascii("o"),
@@ -224893,12 +224893,12 @@ pub static WORD_ALLW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=3,
 };
 
-static WORD_ALLT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLT_CHILDREN),
+static WORD_ALLT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernate"),
         dictgen::InsensitiveStr::Ascii("hough"),
@@ -224922,23 +224922,23 @@ pub static WORD_ALLT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_ALLS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLS_CHILDREN),
+static WORD_ALLS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLS_CHILDREN),
     value: Some(&["all", "falls"]),
 };
 
-pub static WORD_ALLS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("o")],
     values: &[&["also"]],
     range: 1..=1,
 };
 
-static WORD_ALLR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLR_CHILDREN),
+static WORD_ALLR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eady"),
         dictgen::InsensitiveStr::Ascii("edy"),
@@ -224949,12 +224949,12 @@ pub static WORD_ALLR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ALLP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLP_CHILDREN),
+static WORD_ALLP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ication"),
         dictgen::InsensitiveStr::Ascii("ications"),
@@ -224963,12 +224963,12 @@ pub static WORD_ALLP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 7..=8,
 };
 
-static WORD_ALLO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALLO_CHILDREN),
+static WORD_ALLO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALLO_CHILDREN),
     value: Some(&["allow"]),
 };
 
-static WORD_ALLO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALLO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ALLOA_NODE),
     None,
     Some(&WORD_ALLOC_NODE),
@@ -224997,12 +224997,12 @@ static WORD_ALLO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALLOW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOW_CHILDREN),
+static WORD_ALLOW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -225020,56 +225020,56 @@ pub static WORD_ALLOW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ALLOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOV_CHILDREN),
+static WORD_ALLOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["allowed"]],
     range: 2..=2,
 };
 
-static WORD_ALLOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOU_CHILDREN),
+static WORD_ALLOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("d")],
     values: &[&["aloud", "allowed"]],
     range: 1..=1,
 };
 
-static WORD_ALLOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOT_CHILDREN),
+static WORD_ALLOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ed")],
     values: &[&["allotted"]],
     range: 2..=2,
 };
 
-static WORD_ALLOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOS_CHILDREN),
+static WORD_ALLOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOS_CHILDREN),
     value: Some(&["allows"]),
 };
 
-pub static WORD_ALLOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ALLOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOP_CHILDREN),
+static WORD_ALLOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("one"),
         dictgen::InsensitiveStr::Ascii("ones"),
@@ -225078,23 +225078,23 @@ pub static WORD_ALLOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ALLOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOO_CHILDREN),
+static WORD_ALLOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cates")],
     values: &[&["allocates"]],
     range: 5..=5,
 };
 
-static WORD_ALLON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLON_CHILDREN),
+static WORD_ALLON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -225103,12 +225103,12 @@ pub static WORD_ALLON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=1,
 };
 
-static WORD_ALLOE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOE_CHILDREN),
+static WORD_ALLOE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ws"),
@@ -225117,12 +225117,12 @@ pub static WORD_ALLOE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_ALLOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOC_CHILDREN),
+static WORD_ALLOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ae"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -225222,12 +225222,12 @@ pub static WORD_ALLOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ALLOA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLOA_CHILDREN),
+static WORD_ALLOA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLOA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLOA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cate"),
         dictgen::InsensitiveStr::Ascii("cte"),
@@ -225243,23 +225243,23 @@ pub static WORD_ALLOA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ALLM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLM_CHILDREN),
+static WORD_ALLM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ost")],
     values: &[&["almost"]],
     range: 3..=3,
 };
 
-static WORD_ALLL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLL_CHILDREN),
+static WORD_ALLL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLL_CHILDREN),
     value: Some(&["all"]),
 };
 
-pub static WORD_ALLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocate"),
         dictgen::InsensitiveStr::Ascii("ocation"),
@@ -225277,23 +225277,23 @@ pub static WORD_ALLL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ALLK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLK_CHILDREN),
+static WORD_ALLK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLK_CHILDREN),
     value: Some(&["all"]),
 };
 
-pub static WORD_ALLK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static WORD_ALLI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLI_CHILDREN),
+static WORD_ALLI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anse"),
         dictgen::InsensitiveStr::Ascii("asing"),
@@ -225333,12 +225333,12 @@ pub static WORD_ALLI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_ALLE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLE_CHILDREN),
+static WORD_ALLE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLE_CHILDREN),
     value: Some(&["all", "alley"]),
 };
 
-pub static WORD_ALLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("dge"),
@@ -225388,12 +225388,12 @@ pub static WORD_ALLE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=8,
 };
 
-static WORD_ALLC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLC_CHILDREN),
+static WORD_ALLC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ateing"),
@@ -225437,12 +225437,12 @@ pub static WORD_ALLC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ALLA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALLA_CHILDREN),
+static WORD_ALLA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALLA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALLA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("critty"),
         dictgen::InsensitiveStr::Ascii("ince"),
@@ -225452,12 +225452,12 @@ pub static WORD_ALLA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ALI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALI_CHILDREN),
+static WORD_ALI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agn"),
         dictgen::InsensitiveStr::Ascii("asas"),
@@ -225581,12 +225581,12 @@ pub static WORD_ALI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ALH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALH_CHILDREN),
+static WORD_ALH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("a"),
         dictgen::InsensitiveStr::Ascii("abet"),
@@ -225632,12 +225632,12 @@ pub static WORD_ALH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_ALG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALG_CHILDREN),
+static WORD_ALG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALG_CHILDREN),
     value: None,
 };
 
-static WORD_ALG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -225666,23 +225666,23 @@ static WORD_ALG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGR_CHILDREN),
+static WORD_ALGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ithm")],
     values: &[&["algorithm"]],
     range: 4..=4,
 };
 
-static WORD_ALGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALGO_CHILDREN),
+static WORD_ALGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALGO_CHILDREN),
     value: None,
 };
 
-static WORD_ALGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALGO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -225711,12 +225711,12 @@ static WORD_ALGO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALGOT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOT_CHILDREN),
+static WORD_ALGOT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hitm"),
         dictgen::InsensitiveStr::Ascii("hitmic"),
@@ -225772,12 +225772,12 @@ pub static WORD_ALGOT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=11,
 };
 
-static WORD_ALGOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ALGOR_CHILDREN),
+static WORD_ALGOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ALGOR_CHILDREN),
     value: None,
 };
 
-static WORD_ALGOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ALGOR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -225806,12 +225806,12 @@ static WORD_ALGOR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ALGORY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORY_CHILDREN),
+static WORD_ALGORY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("them"),
         dictgen::InsensitiveStr::Ascii("themic"),
@@ -225837,12 +225837,12 @@ pub static WORD_ALGORY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=10,
 };
 
-static WORD_ALGORW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORW_CHILDREN),
+static WORD_ALGORW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("withm"),
         dictgen::InsensitiveStr::Ascii("withmic"),
@@ -225858,12 +225858,12 @@ pub static WORD_ALGORW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 5..=11,
 };
 
-static WORD_ALGORU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORU_CHILDREN),
+static WORD_ALGORU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thm"),
         dictgen::InsensitiveStr::Ascii("thmic"),
@@ -225879,12 +225879,12 @@ pub static WORD_ALGORU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=9,
 };
 
-static WORD_ALGORT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORT_CHILDREN),
+static WORD_ALGORT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("him"),
         dictgen::InsensitiveStr::Ascii("himic"),
@@ -225972,12 +225972,12 @@ pub static WORD_ALGORT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_ALGORR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORR_CHILDREN),
+static WORD_ALGORR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226001,12 +226001,12 @@ pub static WORD_ALGORR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=10,
 };
 
-static WORD_ALGORO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORO_CHILDREN),
+static WORD_ALGORO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226038,12 +226038,12 @@ pub static WORD_ALGORO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 3..=11,
 };
 
-static WORD_ALGORI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORI_CHILDREN),
+static WORD_ALGORI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghtm"),
         dictgen::InsensitiveStr::Ascii("ghtmic"),
@@ -226161,12 +226161,12 @@ pub static WORD_ALGORI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_ALGORH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORH_CHILDREN),
+static WORD_ALGORH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226214,12 +226214,12 @@ pub static WORD_ALGORH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 2..=10,
 };
 
-static WORD_ALGORG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGORG_CHILDREN),
+static WORD_ALGORG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGORG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGORG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226235,12 +226235,12 @@ pub static WORD_ALGORG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTabl
     range: 4..=10,
 };
 
-static WORD_ALGOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOP_CHILDREN),
+static WORD_ALGOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rithm"),
         dictgen::InsensitiveStr::Ascii("rithmic"),
@@ -226256,12 +226256,12 @@ pub static WORD_ALGOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ALGOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOO_CHILDREN),
+static WORD_ALGOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rithm"),
         dictgen::InsensitiveStr::Ascii("rithmic"),
@@ -226277,12 +226277,12 @@ pub static WORD_ALGOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ALGOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOL_CHILDREN),
+static WORD_ALGOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ithm"),
         dictgen::InsensitiveStr::Ascii("ithmic"),
@@ -226298,12 +226298,12 @@ pub static WORD_ALGOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=10,
 };
 
-static WORD_ALGOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOI_CHILDREN),
+static WORD_ALGOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rthm"),
         dictgen::InsensitiveStr::Ascii("rthmic"),
@@ -226327,12 +226327,12 @@ pub static WORD_ALGOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ALGOH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGOH_CHILDREN),
+static WORD_ALGOH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGOH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGOH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("m"),
         dictgen::InsensitiveStr::Ascii("mic"),
@@ -226348,12 +226348,12 @@ pub static WORD_ALGOH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ALGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGI_CHILDREN),
+static WORD_ALGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ned"),
         dictgen::InsensitiveStr::Ascii("nment"),
@@ -226363,12 +226363,12 @@ pub static WORD_ALGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ALGH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGH_CHILDREN),
+static WORD_ALGH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orithm"),
         dictgen::InsensitiveStr::Ascii("orithms"),
@@ -226388,12 +226388,12 @@ pub static WORD_ALGH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ALGE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALGE_CHILDREN),
+static WORD_ALGE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALGE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALGE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("braical"),
         dictgen::InsensitiveStr::Ascii("briac"),
@@ -226413,12 +226413,12 @@ pub static WORD_ALGE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ALF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALF_CHILDREN),
+static WORD_ALF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orithm"),
         dictgen::InsensitiveStr::Ascii("orithmic"),
@@ -226434,12 +226434,12 @@ pub static WORD_ALF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=12,
 };
 
-static WORD_ALE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALE_CHILDREN),
+static WORD_ALE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ady"),
         dictgen::InsensitiveStr::Ascii("ays"),
@@ -226495,23 +226495,23 @@ pub static WORD_ALE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ALD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALD_CHILDREN),
+static WORD_ALD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("utery")],
     values: &[&["adultery"]],
     range: 5..=5,
 };
 
-static WORD_ALC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALC_CHILDREN),
+static WORD_ALC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ehmist"),
         dictgen::InsensitiveStr::Ascii("emy"),
@@ -226567,12 +226567,12 @@ pub static WORD_ALC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_ALB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALB_CHILDREN),
+static WORD_ALB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iet"),
         dictgen::InsensitiveStr::Ascii("umns"),
@@ -226581,12 +226581,12 @@ pub static WORD_ALB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=4,
 };
 
-static WORD_ALA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ALA_CHILDREN),
+static WORD_ALA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ALA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ALA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("is"),
         dictgen::InsensitiveStr::Ascii("ising"),
@@ -226597,12 +226597,12 @@ pub static WORD_ALA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=5,
 };
 
-static WORD_AK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AK_CHILDREN),
+static WORD_AK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AK_CHILDREN),
     value: None,
 };
 
-pub static WORD_AK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("kumulate"),
@@ -226666,12 +226666,12 @@ pub static WORD_AK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_AJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AJ_CHILDREN),
+static WORD_AJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_AJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acence"),
         dictgen::InsensitiveStr::Ascii("acencies"),
@@ -226715,12 +226715,12 @@ pub static WORD_AJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=8,
 };
 
-static WORD_AI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AI_CHILDREN),
+static WORD_AI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("craft"),
         dictgen::InsensitiveStr::Ascii("ffer"),
@@ -226800,12 +226800,12 @@ pub static WORD_AI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=12,
 };
 
-static WORD_AH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AH_CHILDREN),
+static WORD_AH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AH_CHILDREN),
     value: None,
 };
 
-pub static WORD_AH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aed"),
         dictgen::InsensitiveStr::Ascii("d"),
@@ -226849,12 +226849,12 @@ pub static WORD_AH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_AG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AG_CHILDREN),
+static WORD_AG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AG_CHILDREN),
     value: None,
 };
 
-static WORD_AG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AG_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AGA_NODE),
     None,
     None,
@@ -226883,12 +226883,12 @@ static WORD_AG_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AGU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGU_CHILDREN),
+static WORD_AGU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mented"),
@@ -226899,23 +226899,23 @@ pub static WORD_AGU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_AGS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGS_CHILDREN),
+static WORD_AGS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGS_CHILDREN),
     value: Some(&["ages", "tags"]),
 };
 
-pub static WORD_AGS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("inst")],
     values: &[&["against"]],
     range: 4..=4,
 };
 
-static WORD_AGR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AGR_CHILDREN),
+static WORD_AGR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AGR_CHILDREN),
     value: None,
 };
 
-static WORD_AGR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AGR_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AGRA_NODE),
     None,
     None,
@@ -226944,12 +226944,12 @@ static WORD_AGR_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AGRU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRU_CHILDREN),
+static WORD_AGRU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRU_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ably"),
@@ -226971,12 +226971,12 @@ pub static WORD_AGRU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_AGRR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRR_CHILDREN),
+static WORD_AGRR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ement"),
@@ -226986,23 +226986,23 @@ pub static WORD_AGRR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_AGRO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRO_CHILDREN),
+static WORD_AGRO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cultural")],
     values: &[&["agricultural"]],
     range: 8..=8,
 };
 
-static WORD_AGRI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRI_CHILDREN),
+static WORD_AGRI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("colture"),
         dictgen::InsensitiveStr::Ascii("culteral"),
@@ -227042,12 +227042,12 @@ pub static WORD_AGRI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=9,
 };
 
-static WORD_AGRG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRG_CHILDREN),
+static WORD_AGRG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ressive"),
         dictgen::InsensitiveStr::Ascii("ressively"),
@@ -227063,12 +227063,12 @@ pub static WORD_AGRG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=9,
 };
 
-static WORD_AGRE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRE_CHILDREN),
+static WORD_AGRE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("eded"),
@@ -227132,12 +227132,12 @@ pub static WORD_AGRE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_AGRA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGRA_CHILDREN),
+static WORD_AGRA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGRA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGRA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cultural"),
         dictgen::InsensitiveStr::Ascii("gates"),
@@ -227161,12 +227161,12 @@ pub static WORD_AGRA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_AGO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGO_CHILDREN),
+static WORD_AGO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nstic"),
         dictgen::InsensitiveStr::Ascii("nsticism"),
@@ -227176,12 +227176,12 @@ pub static WORD_AGO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_AGN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGN_CHILDREN),
+static WORD_AGN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGN_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ositc"),
         dictgen::InsensitiveStr::Ascii("ostacism"),
@@ -227215,12 +227215,12 @@ pub static WORD_AGN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=9,
 };
 
-static WORD_AGL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGL_CHILDREN),
+static WORD_AGL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGL_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orithm"),
         dictgen::InsensitiveStr::Ascii("orithms"),
@@ -227229,23 +227229,23 @@ pub static WORD_AGL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 6..=7,
 };
 
-static WORD_AGK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGK_CHILDREN),
+static WORD_AGK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGK_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("nowledged")],
     values: &[&["acknowledged"]],
     range: 9..=9,
 };
 
-static WORD_AGI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGI_CHILDREN),
+static WORD_AGI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("an"),
         dictgen::InsensitiveStr::Ascii("anst"),
@@ -227267,12 +227267,12 @@ pub static WORD_AGI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_AGG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGG_CHILDREN),
+static WORD_AGG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aravates"),
         dictgen::InsensitiveStr::Ascii("egate"),
@@ -227394,12 +227394,12 @@ pub static WORD_AGG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_AGA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AGA_CHILDREN),
+static WORD_AGA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AGA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AGA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("i"),
         dictgen::InsensitiveStr::Ascii("innst"),
@@ -227437,12 +227437,12 @@ pub static WORD_AGA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=5,
 };
 
-static WORD_AF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AF_CHILDREN),
+static WORD_AF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AF_CHILDREN),
     value: None,
 };
 
-static WORD_AF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AF_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_AFA_NODE),
     None,
     None,
@@ -227471,23 +227471,23 @@ static WORD_AF_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_AFW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFW_CHILDREN),
+static WORD_AFW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFW_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ully")],
     values: &[&["awfully"]],
     range: 4..=4,
 };
 
-static WORD_AFT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFT_CHILDREN),
+static WORD_AFT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFT_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("erawards"),
@@ -227533,12 +227533,12 @@ pub static WORD_AFT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=9,
 };
 
-static WORD_AFR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFR_CHILDREN),
+static WORD_AFR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFR_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("iad"),
@@ -227562,12 +227562,12 @@ pub static WORD_AFR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_AFO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFO_CHILDREN),
+static WORD_AFO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFO_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rd"),
@@ -227589,12 +227589,12 @@ pub static WORD_AFO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=12,
 };
 
-static WORD_AFI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFI_CHILDREN),
+static WORD_AFI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFI_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nity"),
         dictgen::InsensitiveStr::Ascii("rcan"),
@@ -227604,23 +227604,23 @@ pub static WORD_AFI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=5,
 };
 
-static WORD_AFH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFH_CHILDREN),
+static WORD_AFH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFH_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ganistan")],
     values: &[&["afghanistan"]],
     range: 8..=8,
 };
 
-static WORD_AFG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFG_CHILDREN),
+static WORD_AFG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFG_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ahnistan"),
         dictgen::InsensitiveStr::Ascii("anhistan"),
@@ -227638,12 +227638,12 @@ pub static WORD_AFG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 8..=9,
 };
 
-static WORD_AFF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFF_CHILDREN),
+static WORD_AFF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFF_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("aires"),
@@ -227759,12 +227759,12 @@ pub static WORD_AFF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_AFE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFE_CHILDREN),
+static WORD_AFE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFE_CHILDREN),
     value: Some(&["safe"]),
 };
 
-pub static WORD_AFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ct"),
         dictgen::InsensitiveStr::Ascii("cting"),
@@ -227786,12 +227786,12 @@ pub static WORD_AFE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=6,
 };
 
-static WORD_AFA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AFA_CHILDREN),
+static WORD_AFA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AFA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AFA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ir"),
         dictgen::InsensitiveStr::Ascii("raid"),
@@ -227800,12 +227800,12 @@ pub static WORD_AFA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_AE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AE_CHILDREN),
+static WORD_AE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AE_CHILDREN),
     value: None,
 };
 
-pub static WORD_AE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("activate"),
         dictgen::InsensitiveStr::Ascii("orspace"),
@@ -227863,12 +227863,12 @@ pub static WORD_AE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=11,
 };
 
-static WORD_AD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AD_CHILDREN),
+static WORD_AD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AD_CHILDREN),
     value: None,
 };
 
-static WORD_AD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AD_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ADA_NODE),
     Some(&WORD_ADB_NODE),
     None,
@@ -227897,23 +227897,23 @@ static WORD_AD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADW_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADW_CHILDREN),
+static WORD_ADW_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADW_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADW_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADW_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ances")],
     values: &[&["advances"]],
     range: 5..=5,
 };
 
-static WORD_ADV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ADV_CHILDREN),
+static WORD_ADV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ADV_CHILDREN),
     value: None,
 };
 
-static WORD_ADV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ADV_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ADVA_NODE),
     None,
     None,
@@ -227942,12 +227942,12 @@ static WORD_ADV_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADVS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVS_CHILDREN),
+static WORD_ADVS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ie"),
         dictgen::InsensitiveStr::Ascii("ied"),
@@ -227958,12 +227958,12 @@ pub static WORD_ADVS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ADVO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVO_CHILDREN),
+static WORD_ADVO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cade"),
         dictgen::InsensitiveStr::Ascii("cats"),
@@ -227973,12 +227973,12 @@ pub static WORD_ADVO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ADVN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVN_CHILDREN),
+static WORD_ADVN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ace"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -227987,12 +227987,12 @@ pub static WORD_ADVN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=3,
 };
 
-static WORD_ADVI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVI_CHILDREN),
+static WORD_ADVI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cable"),
         dictgen::InsensitiveStr::Ascii("ced"),
@@ -228024,12 +228024,12 @@ pub static WORD_ADVI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ADVE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVE_CHILDREN),
+static WORD_ADVE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nced"),
         dictgen::InsensitiveStr::Ascii("ntageous"),
@@ -228123,12 +228123,12 @@ pub static WORD_ADVE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ADVA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADVA_CHILDREN),
+static WORD_ADVA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADVA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADVA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("cne"),
@@ -228174,12 +228174,12 @@ pub static WORD_ADVA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ADU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADU_CHILDREN),
+static WORD_ADU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iobook"),
         dictgen::InsensitiveStr::Ascii("ltey"),
@@ -228197,12 +228197,12 @@ pub static WORD_ADU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ADT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADT_CHILDREN),
+static WORD_ADT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("odetect"),
@@ -228211,12 +228211,12 @@ pub static WORD_ADT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ADR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADR_CHILDREN),
+static WORD_ADR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ea"),
         dictgen::InsensitiveStr::Ascii("eanline"),
@@ -228272,12 +228272,12 @@ pub static WORD_ADR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ADQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADQ_CHILDREN),
+static WORD_ADQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uire"),
         dictgen::InsensitiveStr::Ascii("uired"),
@@ -228288,12 +228288,12 @@ pub static WORD_ADQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ADP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADP_CHILDREN),
+static WORD_ADP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apted"),
         dictgen::InsensitiveStr::Ascii("apter"),
@@ -228321,12 +228321,12 @@ pub static WORD_ADP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ADO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADO_CHILDREN),
+static WORD_ADO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bted"),
         dictgen::InsensitiveStr::Ascii("lecent"),
@@ -228368,23 +228368,23 @@ pub static WORD_ADO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_ADN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADN_CHILDREN),
+static WORD_ADN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADN_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ADN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("imistrator")],
     values: &[&["administrators"]],
     range: 10..=10,
 };
 
-static WORD_ADM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ADM_CHILDREN),
+static WORD_ADM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ADM_CHILDREN),
     value: None,
 };
 
-static WORD_ADM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ADM_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -228413,23 +228413,23 @@ static WORD_ADM_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADMR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMR_CHILDREN),
+static WORD_ADMR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ial")],
     values: &[&["admiral"]],
     range: 3..=3,
 };
 
-static WORD_ADMN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMN_CHILDREN),
+static WORD_ADMN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMN_CHILDREN),
     value: Some(&["admin"]),
 };
 
-pub static WORD_ADMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("istrator"),
         dictgen::InsensitiveStr::Ascii("istrators"),
@@ -228438,12 +228438,12 @@ pub static WORD_ADMN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 8..=9,
 };
 
-static WORD_ADMI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ADMI_CHILDREN),
+static WORD_ADMI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ADMI_CHILDREN),
     value: Some(&["admin"]),
 };
 
-static WORD_ADMI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ADMI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -228472,12 +228472,12 @@ static WORD_ADMI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADMIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMIT_CHILDREN),
+static WORD_ADMIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("edly"),
@@ -228497,12 +228497,12 @@ pub static WORD_ADMIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ADMIS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMIS_CHILDREN),
+static WORD_ADMIS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMIS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMIS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ible"),
         dictgen::InsensitiveStr::Ascii("sability"),
@@ -228518,23 +228518,23 @@ pub static WORD_ADMIS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_ADMIR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMIR_CHILDREN),
+static WORD_ADMIR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMIR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMIR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMIR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("aal")],
     values: &[&["admiral"]],
     range: 3..=3,
 };
 
-static WORD_ADMIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADMIN_CHILDREN),
+static WORD_ADMIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADMIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADMIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADMIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("astrator"),
         dictgen::InsensitiveStr::Ascii("g"),
@@ -228648,23 +228648,23 @@ pub static WORD_ADMIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=11,
 };
 
-static WORD_ADME_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADME_CHILDREN),
+static WORD_ADME_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADME_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADME_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADME_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ndment")],
     values: &[&["amendment"]],
     range: 6..=6,
 };
 
-static WORD_ADK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADK_CHILDREN),
+static WORD_ADK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nowledged"),
         dictgen::InsensitiveStr::Ascii("nowledges"),
@@ -228673,12 +228673,12 @@ pub static WORD_ADK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 9..=9,
 };
 
-static WORD_ADJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADJ_CHILDREN),
+static WORD_ADJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acancy"),
         dictgen::InsensitiveStr::Ascii("acentcy"),
@@ -228782,12 +228782,12 @@ pub static WORD_ADJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=12,
 };
 
-static WORD_ADI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADI_CHILDREN),
+static WORD_ADI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acent"),
         dictgen::InsensitiveStr::Ascii("diton"),
@@ -228831,12 +228831,12 @@ pub static WORD_ADI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ADH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADH_CHILDREN),
+static WORD_ADH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earing"),
         dictgen::InsensitiveStr::Ascii("easive"),
@@ -228856,12 +228856,12 @@ pub static WORD_ADH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_ADG_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADG_CHILDREN),
+static WORD_ADG_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADG_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADG_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("es"),
@@ -228870,23 +228870,23 @@ pub static WORD_ADG_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=2,
 };
 
-static WORD_ADF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADF_CHILDREN),
+static WORD_ADF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ter")],
     values: &[&["after"]],
     range: 3..=3,
 };
 
-static WORD_ADE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADE_CHILDREN),
+static WORD_ADE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alide"),
         dictgen::InsensitiveStr::Ascii("cuate"),
@@ -228936,12 +228936,12 @@ pub static WORD_ADE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ADD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ADD_CHILDREN),
+static WORD_ADD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ADD_CHILDREN),
     value: None,
 };
 
-static WORD_ADD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ADD_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ADDA_NODE),
     None,
     Some(&WORD_ADDC_NODE),
@@ -228970,12 +228970,12 @@ static WORD_ADD_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ADDT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDT_CHILDREN),
+static WORD_ADDT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ion"),
@@ -228995,12 +228995,12 @@ pub static WORD_ADDT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=7,
 };
 
-static WORD_ADDR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDR_CHILDREN),
+static WORD_ADDR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ass"),
         dictgen::InsensitiveStr::Ascii("ees"),
@@ -229082,23 +229082,23 @@ pub static WORD_ADDR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_ADDP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDP_CHILDREN),
+static WORD_ADDP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ress")],
     values: &[&["address"]],
     range: 4..=4,
 };
 
-static WORD_ADDO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDO_CHILDREN),
+static WORD_ADDO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nts"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -229116,23 +229116,23 @@ pub static WORD_ADDO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ADDN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDN_CHILDREN),
+static WORD_ADDN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("os")],
     values: &[&["addons"]],
     range: 2..=2,
 };
 
-static WORD_ADDM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDM_CHILDREN),
+static WORD_ADDM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ission"),
         dictgen::InsensitiveStr::Ascii("it"),
@@ -229141,12 +229141,12 @@ pub static WORD_ADDM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ADDJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDJ_CHILDREN),
+static WORD_ADDJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ust"),
         dictgen::InsensitiveStr::Ascii("usted"),
@@ -229157,12 +229157,12 @@ pub static WORD_ADDJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ADDI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDI_CHILDREN),
+static WORD_ADDI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ation"),
         dictgen::InsensitiveStr::Ascii("cionally"),
@@ -229270,12 +229270,12 @@ pub static WORD_ADDI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ADDE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDE_CHILDREN),
+static WORD_ADDE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dd"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -229305,12 +229305,12 @@ pub static WORD_ADDE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ADDD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDD_CHILDREN),
+static WORD_ADDD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDD_CHILDREN),
     value: Some(&["add"]),
 };
 
-pub static WORD_ADDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ed"),
         dictgen::InsensitiveStr::Ascii("ing"),
@@ -229332,23 +229332,23 @@ pub static WORD_ADDD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ADDC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDC_CHILDREN),
+static WORD_ADDC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("its")],
     values: &[&["addicts"]],
     range: 3..=3,
 };
 
-static WORD_ADDA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADDA_CHILDREN),
+static WORD_ADDA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADDA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADDA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pt"),
         dictgen::InsensitiveStr::Ascii("ptation"),
@@ -229368,12 +229368,12 @@ pub static WORD_ADDA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=8,
 };
 
-static WORD_ADB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADB_CHILDREN),
+static WORD_ADB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andon"),
         dictgen::InsensitiveStr::Ascii("omen"),
@@ -229384,12 +229384,12 @@ pub static WORD_ADB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=6,
 };
 
-static WORD_ADA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ADA_CHILDREN),
+static WORD_ADA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ADA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ADA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ADA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ment"),
         dictgen::InsensitiveStr::Ascii("mently"),
@@ -229461,12 +229461,12 @@ pub static WORD_ADA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_AC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AC_CHILDREN),
+static WORD_AC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AC_CHILDREN),
     value: None,
 };
 
-static WORD_AC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACA_NODE),
     None,
     Some(&WORD_ACC_NODE),
@@ -229495,23 +229495,23 @@ static WORD_AC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACY_CHILDREN),
+static WORD_ACY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rlic")],
     values: &[&["acrylic"]],
     range: 4..=4,
 };
 
-static WORD_ACU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACU_CHILDREN),
+static WORD_ACU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("ally"),
@@ -229573,12 +229573,12 @@ pub static WORD_ACU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ACT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACT_CHILDREN),
+static WORD_ACT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACT_CHILDREN),
     value: None,
 };
 
-static WORD_ACT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACT_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACTA_NODE),
     None,
     None,
@@ -229607,23 +229607,23 @@ static WORD_ACT_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACTZ_NODE),
 ];
 
-static WORD_ACTZ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTZ_CHILDREN),
+static WORD_ACTZ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTZ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTZ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTZ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["actual"]],
     range: 2..=2,
 };
 
-static WORD_ACTV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTV_CHILDREN),
+static WORD_ACTV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ated"),
         dictgen::InsensitiveStr::Ascii("e"),
@@ -229634,12 +229634,12 @@ pub static WORD_ACTV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ACTU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTU_CHILDREN),
+static WORD_ACTU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aal"),
         dictgen::InsensitiveStr::Ascii("aally"),
@@ -229701,12 +229701,12 @@ pub static WORD_ACTU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ACTR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTR_CHILDREN),
+static WORD_ACTR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("esess"),
         dictgen::InsensitiveStr::Ascii("esss"),
@@ -229715,23 +229715,23 @@ pub static WORD_ACTR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=5,
 };
 
-static WORD_ACTO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTO_CHILDREN),
+static WORD_ACTO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ve")],
     values: &[&["active"]],
     range: 2..=2,
 };
 
-static WORD_ACTI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACTI_CHILDREN),
+static WORD_ACTI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACTI_CHILDREN),
     value: None,
 };
 
-static WORD_ACTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACTI_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACTIA_NODE),
     Some(&WORD_ACTIB_NODE),
     Some(&WORD_ACTIC_NODE),
@@ -229760,12 +229760,12 @@ static WORD_ACTI_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACTIV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIV_CHILDREN),
+static WORD_ACTIV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIV_CHILDREN),
     value: Some(&["active"]),
 };
 
-pub static WORD_ACTIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acion"),
         dictgen::InsensitiveStr::Ascii("aed"),
@@ -229869,45 +229869,45 @@ pub static WORD_ACTIV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ACTIU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIU_CHILDREN),
+static WORD_ACTIU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("al")],
     values: &[&["actual"]],
     range: 2..=2,
 };
 
-static WORD_ACTIT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIT_CHILDREN),
+static WORD_ACTIT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ivies")],
     values: &[&["activities"]],
     range: 5..=5,
 };
 
-static WORD_ACTIN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIN_CHILDREN),
+static WORD_ACTIN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["active"]],
     range: 1..=1,
 };
 
-static WORD_ACTIC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIC_CHILDREN),
+static WORD_ACTIC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ated"),
@@ -229925,23 +229925,23 @@ pub static WORD_ACTIC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ACTIB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIB_CHILDREN),
+static WORD_ACTIB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ity")],
     values: &[&["activity"]],
     range: 3..=3,
 };
 
-static WORD_ACTIA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTIA_CHILDREN),
+static WORD_ACTIA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTIA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTIA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -229969,12 +229969,12 @@ pub static WORD_ACTIA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ACTA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACTA_CHILDREN),
+static WORD_ACTA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACTA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACTA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("l"),
         dictgen::InsensitiveStr::Ascii("lly"),
@@ -229994,12 +229994,12 @@ pub static WORD_ACTA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ACS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACS_CHILDREN),
+static WORD_ACS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ended"),
         dictgen::InsensitiveStr::Ascii("ending"),
@@ -230023,12 +230023,12 @@ pub static WORD_ACS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ACR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACR_CHILDREN),
+static WORD_ACR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("age"),
         dictgen::InsensitiveStr::Ascii("lyic"),
@@ -230064,12 +230064,12 @@ pub static WORD_ACR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=6,
 };
 
-static WORD_ACQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACQ_CHILDREN),
+static WORD_ACQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("auinted"),
         dictgen::InsensitiveStr::Ascii("uaintace"),
@@ -230163,12 +230163,12 @@ pub static WORD_ACQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=10,
 };
 
-static WORD_ACO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACO_CHILDREN),
+static WORD_ACO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cunt"),
         dictgen::InsensitiveStr::Ascii("mmodate"),
@@ -230248,12 +230248,12 @@ pub static WORD_ACO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=11,
 };
 
-static WORD_ACN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACN_CHILDREN),
+static WORD_ACN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACN_CHILDREN),
     value: Some(&["can", "acne"]),
 };
 
-pub static WORD_ACN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("edote"),
         dictgen::InsensitiveStr::Ascii("owledge"),
@@ -230262,23 +230262,23 @@ pub static WORD_ACN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=7,
 };
 
-static WORD_ACL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACL_CHILDREN),
+static WORD_ACL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("hemist")],
     values: &[&["alchemist"]],
     range: 6..=6,
 };
 
-static WORD_ACK_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACK_CHILDREN),
+static WORD_ACK_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACK_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACK_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nodledgment"),
         dictgen::InsensitiveStr::Ascii("nodledgments"),
@@ -230390,12 +230390,12 @@ pub static WORD_ACK_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=13,
 };
 
-static WORD_ACI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACI_CHILDREN),
+static WORD_ACI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACI_CHILDREN),
     value: Some(&["acpi"]),
 };
 
-pub static WORD_ACI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dent"),
         dictgen::InsensitiveStr::Ascii("dental"),
@@ -230445,12 +230445,12 @@ pub static WORD_ACI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=8,
 };
 
-static WORD_ACH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACH_CHILDREN),
+static WORD_ACH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eevable"),
         dictgen::InsensitiveStr::Ascii("eeve"),
@@ -230556,23 +230556,23 @@ pub static WORD_ACH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ACF_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACF_CHILDREN),
+static WORD_ACF_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACF_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACF_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACF_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tually")],
     values: &[&["factually"]],
     range: 6..=6,
 };
 
-static WORD_ACE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACE_CHILDREN),
+static WORD_ACE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cess"),
         dictgen::InsensitiveStr::Ascii("damia"),
@@ -230636,12 +230636,12 @@ pub static WORD_ACE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_ACD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACD_CHILDREN),
+static WORD_ACD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ept"),
         dictgen::InsensitiveStr::Ascii("itionally"),
@@ -230650,12 +230650,12 @@ pub static WORD_ACD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 3..=9,
 };
 
-static WORD_ACC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACC_CHILDREN),
+static WORD_ACC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACC_CHILDREN),
     value: None,
 };
 
-static WORD_ACC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACC_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACCA_NODE),
     None,
     Some(&WORD_ACCC_NODE),
@@ -230684,12 +230684,12 @@ static WORD_ACC_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACCU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACCU_CHILDREN),
+static WORD_ACCU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACCU_CHILDREN),
     value: None,
 };
 
-static WORD_ACCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACCU_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ACCUA_NODE),
     None,
     None,
@@ -230718,23 +230718,23 @@ static WORD_ACCU_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACCUT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUT_CHILDREN),
+static WORD_ACCUT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&["acute"]],
     range: 1..=1,
 };
 
-static WORD_ACCUS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUS_CHILDREN),
+static WORD_ACCUS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ating"),
         dictgen::InsensitiveStr::Ascii("ato"),
@@ -230754,12 +230754,12 @@ pub static WORD_ACCUS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ACCUR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUR_CHILDREN),
+static WORD_ACCUR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("accies"),
@@ -230801,12 +230801,12 @@ pub static WORD_ACCUR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ACCUP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUP_CHILDREN),
+static WORD_ACCUP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -230815,23 +230815,23 @@ pub static WORD_ACCUP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=3,
 };
 
-static WORD_ACCUN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUN_CHILDREN),
+static WORD_ACCUN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["account"]],
     range: 1..=1,
 };
 
-static WORD_ACCUM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUM_CHILDREN),
+static WORD_ACCUM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alate"),
         dictgen::InsensitiveStr::Ascii("alated"),
@@ -230907,12 +230907,12 @@ pub static WORD_ACCUM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=8,
 };
 
-static WORD_ACCUL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUL_CHILDREN),
+static WORD_ACCUL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("umate"),
         dictgen::InsensitiveStr::Ascii("umated"),
@@ -230928,12 +230928,12 @@ pub static WORD_ACCUL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=7,
 };
 
-static WORD_ACCUA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCUA_CHILDREN),
+static WORD_ACCUA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCUA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCUA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lly"),
         dictgen::InsensitiveStr::Ascii("rcy"),
@@ -230951,12 +230951,12 @@ pub static WORD_ACCUA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ACCT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCT_CHILDREN),
+static WORD_ACCT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ual"),
         dictgen::InsensitiveStr::Ascii("ually"),
@@ -230965,12 +230965,12 @@ pub static WORD_ACCT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=5,
 };
 
-static WORD_ACCS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCS_CHILDREN),
+static WORD_ACCS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("s"),
@@ -230981,12 +230981,12 @@ pub static WORD_ACCS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=5,
 };
 
-static WORD_ACCR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCR_CHILDREN),
+static WORD_ACCR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("acy"),
         dictgen::InsensitiveStr::Ascii("ate"),
@@ -231030,12 +231030,12 @@ pub static WORD_ACCR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ACCQ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCQ_CHILDREN),
+static WORD_ACCQ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCQ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCQ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uainted"),
         dictgen::InsensitiveStr::Ascii("uire"),
@@ -231053,12 +231053,12 @@ pub static WORD_ACCQ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ACCP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCP_CHILDREN),
+static WORD_ACCP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("et"),
         dictgen::InsensitiveStr::Ascii("etable"),
@@ -231078,12 +231078,12 @@ pub static WORD_ACCP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ACCO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACCO_CHILDREN),
+static WORD_ACCO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACCO_CHILDREN),
     value: None,
 };
 
-static WORD_ACCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACCO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_ACCOC_NODE),
@@ -231112,12 +231112,12 @@ static WORD_ACCO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACCOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOU_CHILDREN),
+static WORD_ACCOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("n"),
         dictgen::InsensitiveStr::Ascii("nd"),
@@ -231167,23 +231167,23 @@ pub static WORD_ACCOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=10,
 };
 
-static WORD_ACCOS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOS_CHILDREN),
+static WORD_ACCOS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOS_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOS_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOS_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("tumed")],
     values: &[&["accustomed"]],
     range: 5..=5,
 };
 
-static WORD_ACCOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOR_CHILDREN),
+static WORD_ACCOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dding"),
         dictgen::InsensitiveStr::Ascii("deon"),
@@ -231245,23 +231245,23 @@ pub static WORD_ACCOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=7,
 };
 
-static WORD_ACCOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOP_CHILDREN),
+static WORD_ACCOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("unt")],
     values: &[&["account"]],
     range: 3..=3,
 };
 
-static WORD_ACCOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOO_CHILDREN),
+static WORD_ACCOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rding"),
         dictgen::InsensitiveStr::Ascii("rdingly"),
@@ -231271,12 +231271,12 @@ pub static WORD_ACCOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ACCON_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCON_CHILDREN),
+static WORD_ACCON_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCON_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCON_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("plishment"),
@@ -231296,12 +231296,12 @@ pub static WORD_ACCON_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=9,
 };
 
-static WORD_ACCOM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOM_CHILDREN),
+static WORD_ACCOM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("adate"),
         dictgen::InsensitiveStr::Ascii("adated"),
@@ -231421,12 +231421,12 @@ pub static WORD_ACCOM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=11,
 };
 
-static WORD_ACCOI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOI_CHILDREN),
+static WORD_ACCOI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nting"),
         dictgen::InsensitiveStr::Ascii("rd"),
@@ -231436,12 +231436,12 @@ pub static WORD_ACCOI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ACCOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOD_CHILDREN),
+static WORD_ACCOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ing"),
         dictgen::InsensitiveStr::Ascii("ingly"),
@@ -231465,12 +231465,12 @@ pub static WORD_ACCOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ACCOC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCOC_CHILDREN),
+static WORD_ACCOC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCOC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCOC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iate"),
         dictgen::InsensitiveStr::Ascii("iated"),
@@ -231490,23 +231490,23 @@ pub static WORD_ACCOC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=7,
 };
 
-static WORD_ACCM_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCM_CHILDREN),
+static WORD_ACCM_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCM_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCM_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCM_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ulate")],
     values: &[&["accumulate"]],
     range: 5..=5,
 };
 
-static WORD_ACCL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCL_CHILDREN),
+static WORD_ACCL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amied"),
         dictgen::InsensitiveStr::Ascii("erate"),
@@ -231530,12 +231530,12 @@ pub static WORD_ACCL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 5..=11,
 };
 
-static WORD_ACCI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCI_CHILDREN),
+static WORD_ACCI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cently"),
         dictgen::InsensitiveStr::Ascii("dant"),
@@ -231605,12 +231605,12 @@ pub static WORD_ACCI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=10,
 };
 
-static WORD_ACCH_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCH_CHILDREN),
+static WORD_ACCH_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCH_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCH_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iev"),
         dictgen::InsensitiveStr::Ascii("ievable"),
@@ -231636,12 +231636,12 @@ pub static WORD_ACCH_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=9,
 };
 
-static WORD_ACCE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ACCE_CHILDREN),
+static WORD_ACCE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ACCE_CHILDREN),
     value: None,
 };
 
-static WORD_ACCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ACCE_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     Some(&WORD_ACCEC_NODE),
@@ -231670,12 +231670,12 @@ static WORD_ACCE_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ACCET_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCET_CHILDREN),
+static WORD_ACCET_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCET_CHILDREN),
     value: Some(&["accept"]),
 };
 
-pub static WORD_ACCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCET_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ps"),
@@ -231685,12 +231685,12 @@ pub static WORD_ACCET_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=4,
 };
 
-static WORD_ACCES_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCES_CHILDREN),
+static WORD_ACCES_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCES_CHILDREN),
     value: Some(&["access"]),
 };
 
-pub static WORD_ACCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCES_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("ed"),
@@ -231804,23 +231804,23 @@ pub static WORD_ACCES_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=9,
 };
 
-static WORD_ACCER_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCER_CHILDREN),
+static WORD_ACCER_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCER_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCER_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCER_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("elate")],
     values: &[&["accelerated"]],
     range: 5..=5,
 };
 
-static WORD_ACCEP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEP_CHILDREN),
+static WORD_ACCEP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atble"),
         dictgen::InsensitiveStr::Ascii("ect"),
@@ -231858,23 +231858,23 @@ pub static WORD_ACCEP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ACCEO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEO_CHILDREN),
+static WORD_ACCEO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("t")],
     values: &[&["accept"]],
     range: 1..=1,
 };
 
-static WORD_ACCEN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEN_CHILDREN),
+static WORD_ACCEN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ding"),
         dictgen::InsensitiveStr::Ascii("sion"),
@@ -231883,12 +231883,12 @@ pub static WORD_ACCEN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ACCEL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEL_CHILDREN),
+static WORD_ACCEL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arate"),
         dictgen::InsensitiveStr::Ascii("arated"),
@@ -231976,12 +231976,12 @@ pub static WORD_ACCEL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=8,
 };
 
-static WORD_ACCEE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEE_CHILDREN),
+static WORD_ACCEE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("s"),
         dictgen::InsensitiveStr::Ascii("ss"),
@@ -231990,23 +231990,23 @@ pub static WORD_ACCEE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=2,
 };
 
-static WORD_ACCED_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCED_CHILDREN),
+static WORD_ACCED_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCED_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCED_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCED_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("entally")],
     values: &[&["accidentally"]],
     range: 7..=7,
 };
 
-static WORD_ACCEC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCEC_CHILDREN),
+static WORD_ACCEC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCEC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCEC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ess"),
         dictgen::InsensitiveStr::Ascii("pt"),
@@ -232016,23 +232016,23 @@ pub static WORD_ACCEC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=4,
 };
 
-static WORD_ACCD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCD_CHILDREN),
+static WORD_ACCD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iently")],
     values: &[&["accidently"]],
     range: 6..=6,
 };
 
-static WORD_ACCC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCC_CHILDREN),
+static WORD_ACCC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ept"),
         dictgen::InsensitiveStr::Ascii("eptable"),
@@ -232098,12 +232098,12 @@ pub static WORD_ACCC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=10,
 };
 
-static WORD_ACCA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACCA_CHILDREN),
+static WORD_ACCA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACCA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACCA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("demic"),
         dictgen::InsensitiveStr::Ascii("demy"),
@@ -232123,12 +232123,12 @@ pub static WORD_ACCA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ACA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ACA_CHILDREN),
+static WORD_ACA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ACA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ACA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("damy"),
         dictgen::InsensitiveStr::Ascii("demcially"),
@@ -232162,12 +232162,12 @@ pub static WORD_ACA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=9,
 };
 
-static WORD_AB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_AB_CHILDREN),
+static WORD_AB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_AB_CHILDREN),
     value: None,
 };
 
-static WORD_AB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_AB_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ABA_NODE),
     Some(&WORD_ABB_NODE),
     Some(&WORD_ABC_NODE),
@@ -232196,23 +232196,23 @@ static WORD_AB_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ABY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABY_CHILDREN),
+static WORD_ABY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("msal")],
     values: &[&["abysmal"]],
     range: 4..=4,
 };
 
-static WORD_ABV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABV_CHILDREN),
+static WORD_ABV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailable"),
         dictgen::InsensitiveStr::Ascii("ious"),
@@ -232221,12 +232221,12 @@ pub static WORD_ABV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=7,
 };
 
-static WORD_ABU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABU_CHILDREN),
+static WORD_ABU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dance"),
         dictgen::InsensitiveStr::Ascii("dances"),
@@ -232268,12 +232268,12 @@ pub static WORD_ABU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=8,
 };
 
-static WORD_ABT_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABT_CHILDREN),
+static WORD_ABT_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABT_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABT_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ract"),
         dictgen::InsensitiveStr::Ascii("racted"),
@@ -232301,12 +232301,12 @@ pub static WORD_ABT_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_ABS_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ABS_CHILDREN),
+static WORD_ABS_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ABS_CHILDREN),
     value: None,
 };
 
-static WORD_ABS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ABS_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     Some(&WORD_ABSA_NODE),
     None,
     Some(&WORD_ABSC_NODE),
@@ -232335,23 +232335,23 @@ static WORD_ABS_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ABSY_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSY_CHILDREN),
+static WORD_ABSY_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSY_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSY_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSY_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("mal")],
     values: &[&["abysmal"]],
     range: 3..=3,
 };
 
-static WORD_ABSU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSU_CHILDREN),
+static WORD_ABSU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ers"),
         dictgen::InsensitiveStr::Ascii("lute"),
@@ -232371,12 +232371,12 @@ pub static WORD_ABSU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=6,
 };
 
-static WORD_ABST_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABST_CHILDREN),
+static WORD_ABST_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABST_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABST_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("act"),
         dictgen::InsensitiveStr::Ascii("acted"),
@@ -232486,12 +232486,12 @@ pub static WORD_ABST_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=7,
 };
 
-static WORD_ABSR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSR_CHILDREN),
+static WORD_ABSR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("obed"),
         dictgen::InsensitiveStr::Ascii("obs"),
@@ -232500,12 +232500,12 @@ pub static WORD_ABSR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 3..=4,
 };
 
-static WORD_ABSO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&WORD_ABSO_CHILDREN),
+static WORD_ABSO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&WORD_ABSO_CHILDREN),
     value: None,
 };
 
-static WORD_ABSO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
+static WORD_ABSO_CHILDREN: [Option<&dictgen::TrieNode<&[&str]>>; 26] = [
     None,
     None,
     None,
@@ -232534,23 +232534,23 @@ static WORD_ABSO_CHILDREN: [Option<&dictgen::DictTrieNode<&[&str]>>; 26] = [
     None,
 ];
 
-static WORD_ABSOV_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOV_CHILDREN),
+static WORD_ABSOV_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOV_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOV_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOV_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("le")],
     values: &[&["absolve"]],
     range: 2..=2,
 };
 
-static WORD_ABSOU_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOU_CHILDREN),
+static WORD_ABSOU_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOU_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOU_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("ldly"),
@@ -232592,12 +232592,12 @@ pub static WORD_ABSOU_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ABSOR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOR_CHILDREN),
+static WORD_ABSOR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bant"),
         dictgen::InsensitiveStr::Ascii("bes"),
@@ -232617,23 +232617,23 @@ pub static WORD_ABSOR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ABSOP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOP_CHILDREN),
+static WORD_ABSOP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("rtion")],
     values: &[&["absorption"]],
     range: 5..=5,
 };
 
-static WORD_ABSOO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOO_CHILDREN),
+static WORD_ABSOO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lute"),
         dictgen::InsensitiveStr::Ascii("lutely"),
@@ -232642,12 +232642,12 @@ pub static WORD_ABSOO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ABSOL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOL_CHILDREN),
+static WORD_ABSOL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ate"),
         dictgen::InsensitiveStr::Ascii("ately"),
@@ -232751,12 +232751,12 @@ pub static WORD_ABSOL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=6,
 };
 
-static WORD_ABSOD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSOD_CHILDREN),
+static WORD_ABSOD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSOD_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSOD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efly"),
         dictgen::InsensitiveStr::Ascii("eflyly"),
@@ -232765,23 +232765,23 @@ pub static WORD_ABSOD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=6,
 };
 
-static WORD_ABSL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSL_CHILDREN),
+static WORD_ABSL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSL_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("outes")],
     values: &[&["absolutes"]],
     range: 5..=5,
 };
 
-static WORD_ABSI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSI_CHILDREN),
+static WORD_ABSI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntence"),
         dictgen::InsensitiveStr::Ascii("tnence"),
@@ -232790,12 +232790,12 @@ pub static WORD_ABSI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 6..=6,
 };
 
-static WORD_ABSE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSE_CHILDREN),
+static WORD_ABSE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("lutely"),
@@ -232815,12 +232815,12 @@ pub static WORD_ABSE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 1..=6,
 };
 
-static WORD_ABSC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSC_CHILDREN),
+static WORD_ABSC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("ound"),
@@ -232829,12 +232829,12 @@ pub static WORD_ABSC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 4..=4,
 };
 
-static WORD_ABSA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABSA_CHILDREN),
+static WORD_ABSA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABSA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABSA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("il"),
         dictgen::InsensitiveStr::Ascii("iling"),
@@ -232844,12 +232844,12 @@ pub static WORD_ABSA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable
     range: 2..=5,
 };
 
-static WORD_ABR_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABR_CHILDREN),
+static WORD_ABR_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABR_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABR_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eviate"),
         dictgen::InsensitiveStr::Ascii("eviated"),
@@ -232889,23 +232889,23 @@ pub static WORD_ABR_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=9,
 };
 
-static WORD_ABP_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABP_CHILDREN),
+static WORD_ABP_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABP_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABP_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABP_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ut")],
     values: &[&["about"]],
     range: 2..=2,
 };
 
-static WORD_ABO_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABO_CHILDREN),
+static WORD_ABO_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABO_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABO_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ce"),
         dictgen::InsensitiveStr::Ascii("dmen"),
@@ -233025,12 +233025,12 @@ pub static WORD_ABO_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=10,
 };
 
-static WORD_ABN_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABN_CHILDREN),
+static WORD_ABN_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABN_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABN_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("oramlly"),
@@ -233052,12 +233052,12 @@ pub static WORD_ABN_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 1..=7,
 };
 
-static WORD_ABL_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABL_CHILDREN),
+static WORD_ABL_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABL_CHILDREN),
     value: Some(&["able"]),
 };
 
-pub static WORD_ABL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABL_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iity"),
         dictgen::InsensitiveStr::Ascii("ity"),
@@ -233075,23 +233075,23 @@ pub static WORD_ABL_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=4,
 };
 
-static WORD_ABJ_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABJ_CHILDREN),
+static WORD_ABJ_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABJ_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABJ_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABJ_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ects")],
     values: &[&["objects"]],
     range: 4..=4,
 };
 
-static WORD_ABI_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABI_CHILDREN),
+static WORD_ABI_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABI_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABI_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gious"),
         dictgen::InsensitiveStr::Ascii("guity"),
@@ -233133,23 +233133,23 @@ pub static WORD_ABI_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=7,
 };
 
-static WORD_ABE_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABE_CHILDREN),
+static WORD_ABE_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABE_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABE_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABE_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ration")],
     values: &[&["aberration"]],
     range: 6..=6,
 };
 
-static WORD_ABD_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABD_CHILDREN),
+static WORD_ABD_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABD_CHILDREN),
     value: Some(&["and"]),
 };
 
-pub static WORD_ABD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABD_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ominable"),
         dictgen::InsensitiveStr::Ascii("omine"),
@@ -233160,23 +233160,23 @@ pub static WORD_ABD_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 5..=8,
 };
 
-static WORD_ABC_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABC_CHILDREN),
+static WORD_ABC_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABC_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABC_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABC_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("k")],
     values: &[&["back"]],
     range: 1..=1,
 };
 
-static WORD_ABB_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABB_CHILDREN),
+static WORD_ABB_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABB_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABB_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("breviated"),
         dictgen::InsensitiveStr::Ascii("eration"),
@@ -233242,12 +233242,12 @@ pub static WORD_ABB_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 2..=10,
 };
 
-static WORD_ABA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_ABA_CHILDREN),
+static WORD_ABA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_ABA_CHILDREN),
     value: None,
 };
 
-pub static WORD_ABA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_ABA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("donded"),
         dictgen::InsensitiveStr::Ascii("donding"),
@@ -233291,12 +233291,12 @@ pub static WORD_ABA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
     range: 4..=8,
 };
 
-static WORD_AA_NODE: dictgen::DictTrieNode<&[&str]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&WORD_AA_CHILDREN),
+static WORD_AA_NODE: dictgen::TrieNode<&[&str]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&WORD_AA_CHILDREN),
     value: None,
 };
 
-pub static WORD_AA_CHILDREN: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_AA_CHILDREN: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccess"),
         dictgen::InsensitiveStr::Ascii("ccessibility"),
diff --git a/crates/typos-dict/tests/codegen.rs b/crates/typos-dict/tests/codegen.rs
index ee1ace5..400e55f 100644
--- a/crates/typos-dict/tests/codegen.rs
+++ b/crates/typos-dict/tests/codegen.rs
@@ -20,13 +20,13 @@ fn codegen() {
         snapbox::file!["../benches/benches/map_codegen.rs"].raw()
     );
 
-    let mut table_content = vec![];
-    generate_table(&mut table_content, "WORD", DICT);
-    let table_content = String::from_utf8(table_content).unwrap();
-    let table_content = codegenrs::rustfmt(&table_content, None).unwrap();
+    let mut ordered_map_content = vec![];
+    generate_ordered_map(&mut ordered_map_content, "WORD", DICT);
+    let ordered_map_content = String::from_utf8(ordered_map_content).unwrap();
+    let ordered_map_content = codegenrs::rustfmt(&ordered_map_content, None).unwrap();
     snapbox::assert_data_eq!(
-        &table_content,
-        snapbox::file!["../benches/benches/table_codegen.rs"].raw()
+        &ordered_map_content,
+        snapbox::file!["../benches/benches/ordered_map_codegen.rs"].raw()
     );
 
     snapbox::assert_data_eq!(
@@ -109,7 +109,7 @@ fn generate_map<W: std::io::Write>(file: &mut W, name: &str, dict: &[u8]) {
         .unwrap();
 }
 
-fn generate_table<W: std::io::Write>(file: &mut W, name: &str, dict: &[u8]) {
+fn generate_ordered_map<W: std::io::Write>(file: &mut W, name: &str, dict: &[u8]) {
     writeln!(
         file,
         "// This file is @generated by {}",
@@ -130,7 +130,7 @@ fn generate_table<W: std::io::Write>(file: &mut W, name: &str, dict: &[u8]) {
     dictgen::DictGen::new()
         .name(name)
         .value_type("&[&str]")
-        .table()
+        .ordered_map()
         .write(
             file,
             records.iter().map(|record| {
diff --git a/crates/typos-vars/src/vars_codegen.rs b/crates/typos-vars/src/vars_codegen.rs
index 1bab111..35d5170 100644
--- a/crates/typos-vars/src/vars_codegen.rs
+++ b/crates/typos-vars/src/vars_codegen.rs
@@ -23,24 +23,24 @@ pub fn corrections(category: crate::Category, options: VariantsMap) -> &'static
     }
 }
 
-pub static VARS: dictgen::DictTrie<&[(u8, &VariantsMap)]> = dictgen::DictTrie {
+pub static VARS: dictgen::Trie<&[(u8, &VariantsMap)]> = dictgen::Trie {
     root: &VARS_NODE,
     unicode: &VARS_UNICODE_TABLE,
     range: 2..=21,
 };
 
-pub static VARS_UNICODE_TABLE: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNICODE_TABLE: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[],
     values: &[],
     range: 0..=0,
 };
 
-static VARS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_CHILDREN),
+static VARS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_CHILDREN),
     value: None,
 };
 
-static VARS_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_A_NODE),
     Some(&VARS_B_NODE),
     Some(&VARS_C_NODE),
@@ -69,12 +69,12 @@ static VARS_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26
     None,
 ];
 
-static VARS_Y_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_Y_CHILDREN),
+static VARS_Y_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_Y_CHILDREN),
     value: None,
 };
 
-pub static VARS_Y_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_Y_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("odeled"),
         dictgen::InsensitiveStr::Ascii("odeler"),
@@ -110,12 +110,12 @@ pub static VARS_Y_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen:
     range: 6..=8,
 };
 
-static VARS_W_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_W_CHILDREN),
+static VARS_W_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_W_CHILDREN),
     value: None,
 };
 
-static VARS_W_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_W_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_WA_NODE),
     None,
     None,
@@ -144,12 +144,12 @@ static VARS_W_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_WO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_WO_CHILDREN),
+static VARS_WO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_WO_CHILDREN),
     value: None,
 };
 
-pub static VARS_WO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_WO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("manise"),
         dictgen::InsensitiveStr::Ascii("manised"),
@@ -213,12 +213,12 @@ pub static VARS_WO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=9,
 };
 
-static VARS_WI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_WI_CHILDREN),
+static VARS_WI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_WI_CHILDREN),
     value: None,
 };
 
-pub static VARS_WI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_WI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfullier"),
         dictgen::InsensitiveStr::Ascii("lfulliest"),
@@ -270,23 +270,23 @@ pub static VARS_WI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=12,
 };
 
-static VARS_WH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_WH_CHILDREN),
+static VARS_WH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_WH_CHILDREN),
     value: None,
 };
 
-pub static VARS_WH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_WH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("iskeys")],
     values: &[&[(0b01001, &ENTRY_WHISKEYS_7436468433370877238)]],
     range: 6..=6,
 };
 
-static VARS_WE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_WE_CHILDREN),
+static VARS_WE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_WE_CHILDREN),
     value: None,
 };
 
-pub static VARS_WE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_WE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aseled"),
         dictgen::InsensitiveStr::Ascii("aseling"),
@@ -310,12 +310,12 @@ pub static VARS_WE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=13,
 };
 
-static VARS_WA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_WA_CHILDREN),
+static VARS_WA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_WA_CHILDREN),
     value: None,
 };
 
-pub static VARS_WA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_WA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ggon"),
         dictgen::InsensitiveStr::Ascii("ggoned"),
@@ -363,12 +363,12 @@ pub static VARS_WA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=13,
 };
 
-static VARS_V_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_V_CHILDREN),
+static VARS_V_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_V_CHILDREN),
     value: None,
 };
 
-static VARS_V_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_V_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_VA_NODE),
     None,
     None,
@@ -397,12 +397,12 @@ static VARS_V_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_VU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VU_CHILDREN),
+static VARS_VU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VU_CHILDREN),
     value: None,
 };
 
-pub static VARS_VU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lcanisation"),
         dictgen::InsensitiveStr::Ascii("lcanisations"),
@@ -466,12 +466,12 @@ pub static VARS_VU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=12,
 };
 
-static VARS_VO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VO_CHILDREN),
+static VARS_VO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VO_CHILDREN),
     value: None,
 };
 
-pub static VARS_VO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("calisation"),
         dictgen::InsensitiveStr::Ascii("calisations"),
@@ -527,12 +527,12 @@ pub static VARS_VO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=13,
 };
 
-static VARS_VI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VI_CHILDREN),
+static VARS_VI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VI_CHILDREN),
     value: None,
 };
 
-pub static VARS_VI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ctimisation"),
         dictgen::InsensitiveStr::Ascii("ctimisations"),
@@ -662,12 +662,12 @@ pub static VARS_VI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=12,
 };
 
-static VARS_VE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VE_CHILDREN),
+static VARS_VE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VE_CHILDREN),
     value: None,
 };
 
-pub static VARS_VE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nder"),
         dictgen::InsensitiveStr::Ascii("nders"),
@@ -727,12 +727,12 @@ pub static VARS_VE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=13,
 };
 
-static VARS_VA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_VA_CHILDREN),
+static VARS_VA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_VA_CHILDREN),
     value: None,
 };
 
-static VARS_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_VA_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -761,12 +761,12 @@ static VARS_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_VAS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VAS_CHILDREN),
+static VARS_VAS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VAS_CHILDREN),
     value: None,
 };
 
-pub static VARS_VAS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VAS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectomise"),
         dictgen::InsensitiveStr::Ascii("ectomised"),
@@ -786,12 +786,12 @@ pub static VARS_VAS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=10,
 };
 
-static VARS_VAR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VAR_CHILDREN),
+static VARS_VAR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VAR_CHILDREN),
     value: None,
 };
 
-pub static VARS_VAR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VAR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("icolored"),
         dictgen::InsensitiveStr::Ascii("icoloredder"),
@@ -815,12 +815,12 @@ pub static VARS_VAR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=13,
 };
 
-static VARS_VAP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VAP_CHILDREN),
+static VARS_VAP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VAP_CHILDREN),
     value: None,
 };
 
-pub static VARS_VAP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VAP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("ored"),
@@ -884,12 +884,12 @@ pub static VARS_VAP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=10,
 };
 
-static VARS_VAN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VAN_CHILDREN),
+static VARS_VAN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VAN_CHILDREN),
     value: None,
 };
 
-pub static VARS_VAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VAN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dalise"),
         dictgen::InsensitiveStr::Ascii("dalised"),
@@ -913,12 +913,12 @@ pub static VARS_VAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_VAL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_VAL_CHILDREN),
+static VARS_VAL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_VAL_CHILDREN),
     value: None,
 };
 
-pub static VARS_VAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_VAL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orisation"),
@@ -958,12 +958,12 @@ pub static VARS_VAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=10,
 };
 
-static VARS_U_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_U_CHILDREN),
+static VARS_U_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_U_CHILDREN),
     value: None,
 };
 
-static VARS_U_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_U_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -992,12 +992,12 @@ static VARS_U_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_UT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UT_CHILDREN),
+static VARS_UT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UT_CHILDREN),
     value: None,
 };
 
-pub static VARS_UT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilisable"),
         dictgen::InsensitiveStr::Ascii("ilisables"),
@@ -1037,23 +1037,23 @@ pub static VARS_UT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=10,
 };
 
-static VARS_US_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_US_CHILDREN),
+static VARS_US_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_US_CHILDREN),
     value: None,
 };
 
-pub static VARS_US_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_US_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eability")],
     values: &[&[(0b00001, &ENTRY_USABILITY_14697152389699662448)]],
     range: 8..=8,
 };
 
-static VARS_UR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UR_CHILDREN),
+static VARS_UR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UR_CHILDREN),
     value: None,
 };
 
-pub static VARS_UR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aemia"),
         dictgen::InsensitiveStr::Ascii("aemias"),
@@ -1097,12 +1097,12 @@ pub static VARS_UR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=11,
 };
 
-static VARS_UP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UP_CHILDREN),
+static VARS_UP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UP_CHILDREN),
     value: None,
 };
 
-pub static VARS_UP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("draft"),
         dictgen::InsensitiveStr::Ascii("drafts"),
@@ -1118,12 +1118,12 @@ pub static VARS_UP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=8,
 };
 
-static VARS_UN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_UN_CHILDREN),
+static VARS_UN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_UN_CHILDREN),
     value: None,
 };
 
-static VARS_UN_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_UN_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_UNA_NODE),
     None,
     Some(&VARS_UNC_NODE),
@@ -1152,12 +1152,12 @@ static VARS_UN_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_UNT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNT_CHILDREN),
+static VARS_UNT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNT_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rammeled"),
         dictgen::InsensitiveStr::Ascii("rammeledder"),
@@ -1177,12 +1177,12 @@ pub static VARS_UNT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=13,
 };
 
-static VARS_UNS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNS_CHILDREN),
+static VARS_UNS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNS_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avorier"),
         dictgen::InsensitiveStr::Ascii("avories"),
@@ -1226,12 +1226,12 @@ pub static VARS_UNS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=14,
 };
 
-static VARS_UNR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNR_CHILDREN),
+static VARS_UNR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNR_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aveled"),
         dictgen::InsensitiveStr::Ascii("aveling"),
@@ -1307,12 +1307,12 @@ pub static VARS_UNR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=13,
 };
 
-static VARS_UNP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNP_CHILDREN),
+static VARS_UNP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNP_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("asteurised"),
         dictgen::InsensitiveStr::Ascii("asteurized"),
@@ -1344,12 +1344,12 @@ pub static VARS_UNP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=12,
 };
 
-static VARS_UNO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNO_CHILDREN),
+static VARS_UNO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNO_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rganised"),
         dictgen::InsensitiveStr::Ascii("rganized"),
@@ -1361,12 +1361,12 @@ pub static VARS_UNO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=8,
 };
 
-static VARS_UNL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNL_CHILDREN),
+static VARS_UNL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNL_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abeled"),
         dictgen::InsensitiveStr::Ascii("abeledder"),
@@ -1388,12 +1388,12 @@ pub static VARS_UNL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=11,
 };
 
-static VARS_UNI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNI_CHILDREN),
+static VARS_UNI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNI_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onisation"),
         dictgen::InsensitiveStr::Ascii("onisations"),
@@ -1449,23 +1449,23 @@ pub static VARS_UNI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=14,
 };
 
-static VARS_UNG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNG_CHILDREN),
+static VARS_UNG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNG_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("lamourous")],
     values: &[&[(0b11010, &ENTRY_UNGLAMOROUS_17159152581421977091)]],
     range: 9..=9,
 };
 
-static VARS_UNF_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNF_CHILDREN),
+static VARS_UNF_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNF_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNF_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avorable"),
         dictgen::InsensitiveStr::Ascii("avorabler"),
@@ -1525,12 +1525,12 @@ pub static VARS_UNF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=13,
 };
 
-static VARS_UNE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNE_CHILDREN),
+static VARS_UNE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNE_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("qualed"),
         dictgen::InsensitiveStr::Ascii("qualedder"),
@@ -1550,12 +1550,12 @@ pub static VARS_UNE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_UND_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UND_CHILDREN),
+static VARS_UND_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UND_CHILDREN),
     value: None,
 };
 
-pub static VARS_UND_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UND_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eremphasise"),
         dictgen::InsensitiveStr::Ascii("eremphasised"),
@@ -1603,12 +1603,12 @@ pub static VARS_UND_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 9..=14,
 };
 
-static VARS_UNC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNC_CHILDREN),
+static VARS_UNC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNC_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ivilised"),
         dictgen::InsensitiveStr::Ascii("ivilized"),
@@ -1636,12 +1636,12 @@ pub static VARS_UNC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_UNA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_UNA_CHILDREN),
+static VARS_UNA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_UNA_CHILDREN),
     value: None,
 };
 
-pub static VARS_UNA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_UNA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ppetising"),
         dictgen::InsensitiveStr::Ascii("ppetisinger"),
@@ -1685,12 +1685,12 @@ pub static VARS_UNA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 9..=14,
 };
 
-static VARS_T_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_T_CHILDREN),
+static VARS_T_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_T_CHILDREN),
     value: None,
 };
 
-static VARS_T_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_T_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_TA_NODE),
     None,
     None,
@@ -1719,12 +1719,12 @@ static VARS_T_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     Some(&VARS_TZ_NODE),
 ];
 
-static VARS_TZ_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TZ_CHILDREN),
+static VARS_TZ_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TZ_CHILDREN),
     value: None,
 };
 
-pub static VARS_TZ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TZ_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ar"),
         dictgen::InsensitiveStr::Ascii("ars"),
@@ -1736,12 +1736,12 @@ pub static VARS_TZ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=3,
 };
 
-static VARS_TY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TY_CHILDREN),
+static VARS_TY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TY_CHILDREN),
     value: None,
 };
 
-pub static VARS_TY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rannise"),
         dictgen::InsensitiveStr::Ascii("rannised"),
@@ -1773,12 +1773,12 @@ pub static VARS_TY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=10,
 };
 
-static VARS_TU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TU_CHILDREN),
+static VARS_TU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TU_CHILDREN),
     value: None,
 };
 
-pub static VARS_TU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("laraemia"),
         dictgen::InsensitiveStr::Ascii("laraemias"),
@@ -1822,12 +1822,12 @@ pub static VARS_TU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=9,
 };
 
-static VARS_TR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_TR_CHILDREN),
+static VARS_TR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_TR_CHILDREN),
     value: None,
 };
 
-static VARS_TR_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_TR_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_TRA_NODE),
     None,
     None,
@@ -1856,12 +1856,12 @@ static VARS_TR_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_TRO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TRO_CHILDREN),
+static VARS_TRO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TRO_CHILDREN),
     value: None,
 };
 
-pub static VARS_TRO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TRO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llied"),
         dictgen::InsensitiveStr::Ascii("llies"),
@@ -1885,12 +1885,12 @@ pub static VARS_TRO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=7,
 };
 
-static VARS_TRI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TRI_CHILDREN),
+static VARS_TRI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TRI_CHILDREN),
     value: None,
 };
 
-pub static VARS_TRI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TRI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aled"),
         dictgen::InsensitiveStr::Ascii("aling"),
@@ -1930,12 +1930,12 @@ pub static VARS_TRI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=12,
 };
 
-static VARS_TRA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TRA_CHILDREN),
+static VARS_TRA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TRA_CHILDREN),
     value: None,
 };
 
-pub static VARS_TRA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TRA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mmeled"),
         dictgen::InsensitiveStr::Ascii("mmeling"),
@@ -2061,12 +2061,12 @@ pub static VARS_TRA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=12,
 };
 
-static VARS_TO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TO_CHILDREN),
+static VARS_TO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TO_CHILDREN),
     value: None,
 };
 
-pub static VARS_TO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("taled"),
         dictgen::InsensitiveStr::Ascii("taling"),
@@ -2130,12 +2130,12 @@ pub static VARS_TO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=11,
 };
 
-static VARS_TI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TI_CHILDREN),
+static VARS_TI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TI_CHILDREN),
     value: None,
 };
 
-pub static VARS_TI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dbit"),
         dictgen::InsensitiveStr::Ascii("dbits"),
@@ -2167,12 +2167,12 @@ pub static VARS_TI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=8,
 };
 
-static VARS_TH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TH_CHILDREN),
+static VARS_TH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TH_CHILDREN),
     value: None,
 };
 
-pub static VARS_TH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eater"),
         dictgen::InsensitiveStr::Ascii("eatergoer"),
@@ -2250,12 +2250,12 @@ pub static VARS_TH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=11,
 };
 
-static VARS_TE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TE_CHILDREN),
+static VARS_TE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TE_CHILDREN),
     value: None,
 };
 
-pub static VARS_TE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aselled"),
         dictgen::InsensitiveStr::Ascii("aseller"),
@@ -2369,12 +2369,12 @@ pub static VARS_TE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=12,
 };
 
-static VARS_TA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_TA_CHILDREN),
+static VARS_TA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_TA_CHILDREN),
     value: None,
 };
 
-pub static VARS_TA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_TA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mboura"),
         dictgen::InsensitiveStr::Ascii("mbouras"),
@@ -2464,12 +2464,12 @@ pub static VARS_TA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=14,
 };
 
-static VARS_S_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_S_CHILDREN),
+static VARS_S_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_S_CHILDREN),
     value: None,
 };
 
-static VARS_S_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_S_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_SA_NODE),
     None,
     Some(&VARS_SC_NODE),
@@ -2498,12 +2498,12 @@ static VARS_S_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_SY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_SY_CHILDREN),
+static VARS_SY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_SY_CHILDREN),
     value: None,
 };
 
-static VARS_SY_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_SY_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -2532,12 +2532,12 @@ static VARS_SY_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_SYS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SYS_CHILDREN),
+static VARS_SYS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SYS_CHILDREN),
     value: None,
 };
 
-pub static VARS_SYS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SYS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tematisation"),
         dictgen::InsensitiveStr::Ascii("tematisations"),
@@ -2609,12 +2609,12 @@ pub static VARS_SYS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=13,
 };
 
-static VARS_SYP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SYP_CHILDREN),
+static VARS_SYP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SYP_CHILDREN),
     value: None,
 };
 
-pub static VARS_SYP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SYP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hon"),
         dictgen::InsensitiveStr::Ascii("honed"),
@@ -2630,12 +2630,12 @@ pub static VARS_SYP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=6,
 };
 
-static VARS_SYN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SYN_CHILDREN),
+static VARS_SYN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SYN_CHILDREN),
     value: None,
 };
 
-pub static VARS_SYN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SYN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chronisation"),
         dictgen::InsensitiveStr::Ascii("chronisations"),
@@ -2735,12 +2735,12 @@ pub static VARS_SYN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=13,
 };
 
-static VARS_SYM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SYM_CHILDREN),
+static VARS_SYM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SYM_CHILDREN),
     value: None,
 };
 
-pub static VARS_SYM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SYM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bolisation"),
         dictgen::InsensitiveStr::Ascii("bolisations"),
@@ -2818,12 +2818,12 @@ pub static VARS_SYM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_SYL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SYL_CHILDREN),
+static VARS_SYL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SYL_CHILDREN),
     value: None,
 };
 
-pub static VARS_SYL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SYL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("labise"),
         dictgen::InsensitiveStr::Ascii("labised"),
@@ -2863,12 +2863,12 @@ pub static VARS_SYL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_SW_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SW_CHILDREN),
+static VARS_SW_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SW_CHILDREN),
     value: None,
 };
 
-pub static VARS_SW_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SW_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iveled"),
         dictgen::InsensitiveStr::Ascii("iveling"),
@@ -2884,12 +2884,12 @@ pub static VARS_SW_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=8,
 };
 
-static VARS_SU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SU_CHILDREN),
+static VARS_SU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SU_CHILDREN),
     value: None,
 };
 
-pub static VARS_SU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bsidisation"),
         dictgen::InsensitiveStr::Ascii("bsidisations"),
@@ -3017,12 +3017,12 @@ pub static VARS_SU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=14,
 };
 
-static VARS_ST_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_ST_CHILDREN),
+static VARS_ST_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_ST_CHILDREN),
     value: None,
 };
 
-static VARS_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_ST_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_STA_NODE),
     None,
     None,
@@ -3051,12 +3051,12 @@ static VARS_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_STY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_STY_CHILDREN),
+static VARS_STY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_STY_CHILDREN),
     value: None,
 };
 
-pub static VARS_STY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_STY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lisation"),
         dictgen::InsensitiveStr::Ascii("lisations"),
@@ -3088,12 +3088,12 @@ pub static VARS_STY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=9,
 };
 
-static VARS_STI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_STI_CHILDREN),
+static VARS_STI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_STI_CHILDREN),
     value: None,
 };
 
-pub static VARS_STI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_STI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gmatisation"),
         dictgen::InsensitiveStr::Ascii("gmatisations"),
@@ -3125,12 +3125,12 @@ pub static VARS_STI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_STE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_STE_CHILDREN),
+static VARS_STE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_STE_CHILDREN),
     value: None,
 };
 
-pub static VARS_STE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_STE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nciled"),
         dictgen::InsensitiveStr::Ascii("nciling"),
@@ -3194,12 +3194,12 @@ pub static VARS_STE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_STA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_STA_CHILDREN),
+static VARS_STA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_STA_CHILDREN),
     value: None,
 };
 
-pub static VARS_STA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_STA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilisation"),
         dictgen::InsensitiveStr::Ascii("bilisations"),
@@ -3263,12 +3263,12 @@ pub static VARS_STA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=13,
 };
 
-static VARS_SQ_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SQ_CHILDREN),
+static VARS_SQ_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SQ_CHILDREN),
     value: None,
 };
 
-pub static VARS_SQ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SQ_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uirreled"),
         dictgen::InsensitiveStr::Ascii("uirreling"),
@@ -3284,12 +3284,12 @@ pub static VARS_SQ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 8..=10,
 };
 
-static VARS_SP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SP_CHILDREN),
+static VARS_SP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SP_CHILDREN),
     value: None,
 };
 
-pub static VARS_SP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecialisation"),
         dictgen::InsensitiveStr::Ascii("ecialisations"),
@@ -3393,12 +3393,12 @@ pub static VARS_SP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=15,
 };
 
-static VARS_SO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_SO_CHILDREN),
+static VARS_SO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_SO_CHILDREN),
     value: None,
 };
 
-static VARS_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_SO_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     Some(&VARS_SOC_NODE),
@@ -3427,12 +3427,12 @@ static VARS_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_SOV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SOV_CHILDREN),
+static VARS_SOV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SOV_CHILDREN),
     value: None,
 };
 
-pub static VARS_SOV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SOV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ietisation"),
         dictgen::InsensitiveStr::Ascii("ietisations"),
@@ -3464,12 +3464,12 @@ pub static VARS_SOV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_SOM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SOM_CHILDREN),
+static VARS_SOM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SOM_CHILDREN),
     value: None,
 };
 
-pub static VARS_SOM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SOM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("berer"),
@@ -3489,12 +3489,12 @@ pub static VARS_SOM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=9,
 };
 
-static VARS_SOL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SOL_CHILDREN),
+static VARS_SOL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SOL_CHILDREN),
     value: None,
 };
 
-pub static VARS_SOL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SOL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arisation"),
         dictgen::InsensitiveStr::Ascii("arisations"),
@@ -3602,12 +3602,12 @@ pub static VARS_SOL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=12,
 };
 
-static VARS_SOD_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SOD_CHILDREN),
+static VARS_SOD_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SOD_CHILDREN),
     value: None,
 };
 
-pub static VARS_SOD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SOD_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omise"),
         dictgen::InsensitiveStr::Ascii("omised"),
@@ -3631,12 +3631,12 @@ pub static VARS_SOD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=7,
 };
 
-static VARS_SOC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SOC_CHILDREN),
+static VARS_SOC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SOC_CHILDREN),
     value: None,
 };
 
-pub static VARS_SOC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SOC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialisation"),
         dictgen::InsensitiveStr::Ascii("ialisations"),
@@ -3668,12 +3668,12 @@ pub static VARS_SOC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_SN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SN_CHILDREN),
+static VARS_SN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SN_CHILDREN),
     value: None,
 };
 
-pub static VARS_SN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iveled"),
         dictgen::InsensitiveStr::Ascii("iveler"),
@@ -3717,12 +3717,12 @@ pub static VARS_SN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=9,
 };
 
-static VARS_SM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SM_CHILDREN),
+static VARS_SM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SM_CHILDREN),
     value: None,
 };
 
-pub static VARS_SM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idge"),
         dictgen::InsensitiveStr::Ascii("idges"),
@@ -3742,12 +3742,12 @@ pub static VARS_SM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=8,
 };
 
-static VARS_SL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SL_CHILDREN),
+static VARS_SL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SL_CHILDREN),
     value: None,
 };
 
-pub static VARS_SL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enderise"),
         dictgen::InsensitiveStr::Ascii("enderised"),
@@ -3777,12 +3777,12 @@ pub static VARS_SL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=10,
 };
 
-static VARS_SK_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SK_CHILDREN),
+static VARS_SK_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SK_CHILDREN),
     value: None,
 };
 
-pub static VARS_SK_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SK_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eptic"),
         dictgen::InsensitiveStr::Ascii("eptical"),
@@ -3810,12 +3810,12 @@ pub static VARS_SK_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=10,
 };
 
-static VARS_SI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SI_CHILDREN),
+static VARS_SI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SI_CHILDREN),
     value: None,
 };
 
-pub static VARS_SI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gnaled"),
         dictgen::InsensitiveStr::Ascii("gnaler"),
@@ -3871,12 +3871,12 @@ pub static VARS_SI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=14,
 };
 
-static VARS_SH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SH_CHILDREN),
+static VARS_SH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SH_CHILDREN),
     value: None,
 };
 
-pub static VARS_SH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aikh"),
         dictgen::InsensitiveStr::Ascii("aikhs"),
@@ -3912,12 +3912,12 @@ pub static VARS_SH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=9,
 };
 
-static VARS_SE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_SE_CHILDREN),
+static VARS_SE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_SE_CHILDREN),
     value: None,
 };
 
-static VARS_SE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_SE_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     Some(&VARS_SEB_NODE),
     Some(&VARS_SEC_NODE),
@@ -3946,12 +3946,12 @@ static VARS_SE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_SER_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SER_CHILDREN),
+static VARS_SER_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SER_CHILDREN),
     value: None,
 };
 
-pub static VARS_SER_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SER_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialisation"),
         dictgen::InsensitiveStr::Ascii("ialisations"),
@@ -4007,12 +4007,12 @@ pub static VARS_SER_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_SEP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SEP_CHILDREN),
+static VARS_SEP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SEP_CHILDREN),
     value: None,
 };
 
-pub static VARS_SEP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SEP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ticaemia"),
         dictgen::InsensitiveStr::Ascii("ticaemias"),
@@ -4048,12 +4048,12 @@ pub static VARS_SEP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=9,
 };
 
-static VARS_SEN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SEN_CHILDREN),
+static VARS_SEN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SEN_CHILDREN),
     value: None,
 };
 
-pub static VARS_SEN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SEN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sationalise"),
         dictgen::InsensitiveStr::Ascii("sationalised"),
@@ -4149,12 +4149,12 @@ pub static VARS_SEN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=16,
 };
 
-static VARS_SEI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SEI_CHILDREN),
+static VARS_SEI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SEI_CHILDREN),
     value: None,
 };
 
-pub static VARS_SEI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SEI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ser"),
         dictgen::InsensitiveStr::Ascii("sers"),
@@ -4170,12 +4170,12 @@ pub static VARS_SEI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=4,
 };
 
-static VARS_SEC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SEC_CHILDREN),
+static VARS_SEC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SEC_CHILDREN),
     value: None,
 };
 
-pub static VARS_SEC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SEC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tionalise"),
         dictgen::InsensitiveStr::Ascii("tionalised"),
@@ -4223,12 +4223,12 @@ pub static VARS_SEC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_SEB_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SEB_CHILDREN),
+static VARS_SEB_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SEB_CHILDREN),
     value: None,
 };
 
-pub static VARS_SEB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SEB_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orrhea"),
         dictgen::InsensitiveStr::Ascii("orrheas"),
@@ -4248,12 +4248,12 @@ pub static VARS_SEB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_SC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SC_CHILDREN),
+static VARS_SC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SC_CHILDREN),
     value: None,
 };
 
-pub static VARS_SC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("andalise"),
         dictgen::InsensitiveStr::Ascii("andalised"),
@@ -4361,12 +4361,12 @@ pub static VARS_SC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=13,
 };
 
-static VARS_SA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_SA_CHILDREN),
+static VARS_SA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_SA_CHILDREN),
     value: None,
 };
 
-static VARS_SA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_SA_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     Some(&VARS_SAB_NODE),
     None,
@@ -4395,12 +4395,12 @@ static VARS_SA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_SAV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SAV_CHILDREN),
+static VARS_SAV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SAV_CHILDREN),
     value: None,
 };
 
-pub static VARS_SAV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SAV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ior"),
         dictgen::InsensitiveStr::Ascii("iors"),
@@ -4476,12 +4476,12 @@ pub static VARS_SAV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=10,
 };
 
-static VARS_SAT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SAT_CHILDREN),
+static VARS_SAT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SAT_CHILDREN),
     value: None,
 };
 
-pub static VARS_SAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SAT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("irisation"),
         dictgen::InsensitiveStr::Ascii("irise"),
@@ -4509,12 +4509,12 @@ pub static VARS_SAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=9,
 };
 
-static VARS_SAN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SAN_CHILDREN),
+static VARS_SAN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SAN_CHILDREN),
     value: None,
 };
 
-pub static VARS_SAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SAN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daled"),
         dictgen::InsensitiveStr::Ascii("daling"),
@@ -4562,12 +4562,12 @@ pub static VARS_SAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_SAL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SAL_CHILDREN),
+static VARS_SAL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SAL_CHILDREN),
     value: None,
 };
 
-pub static VARS_SAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SAL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("abler"),
@@ -4593,12 +4593,12 @@ pub static VARS_SAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=9,
 };
 
-static VARS_SAB_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_SAB_CHILDREN),
+static VARS_SAB_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_SAB_CHILDREN),
     value: None,
 };
 
-pub static VARS_SAB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_SAB_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -4614,12 +4614,12 @@ pub static VARS_SAB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=5,
 };
 
-static VARS_R_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_R_CHILDREN),
+static VARS_R_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_R_CHILDREN),
     value: None,
 };
 
-static VARS_R_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_R_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_RA_NODE),
     None,
     None,
@@ -4648,12 +4648,12 @@ static VARS_R_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_RU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_RU_CHILDREN),
+static VARS_RU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_RU_CHILDREN),
     value: None,
 };
 
-pub static VARS_RU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_RU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bberise"),
         dictgen::InsensitiveStr::Ascii("bberised"),
@@ -4717,12 +4717,12 @@ pub static VARS_RU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=11,
 };
 
-static VARS_RO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_RO_CHILDREN),
+static VARS_RO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_RO_CHILDREN),
     value: None,
 };
 
-pub static VARS_RO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_RO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("botisation"),
         dictgen::InsensitiveStr::Ascii("botisations"),
@@ -4826,12 +4826,12 @@ pub static VARS_RO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=14,
 };
 
-static VARS_RI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_RI_CHILDREN),
+static VARS_RI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_RI_CHILDREN),
     value: None,
 };
 
-pub static VARS_RI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_RI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gor"),
         dictgen::InsensitiveStr::Ascii("gors"),
@@ -4879,12 +4879,12 @@ pub static VARS_RI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=12,
 };
 
-static VARS_RH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_RH_CHILDREN),
+static VARS_RH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_RH_CHILDREN),
     value: None,
 };
 
-pub static VARS_RH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_RH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apsodise"),
         dictgen::InsensitiveStr::Ascii("apsodised"),
@@ -4908,12 +4908,12 @@ pub static VARS_RH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 8..=10,
 };
 
-static VARS_RE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_RE_CHILDREN),
+static VARS_RE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_RE_CHILDREN),
     value: None,
 };
 
-static VARS_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_RE_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_REA_NODE),
     None,
     Some(&VARS_REC_NODE),
@@ -4942,12 +4942,12 @@ static VARS_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_REV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REV_CHILDREN),
+static VARS_REV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REV_CHILDREN),
     value: None,
 };
 
-pub static VARS_REV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eler"),
@@ -5015,12 +5015,12 @@ pub static VARS_REV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=12,
 };
 
-static VARS_REP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REP_CHILDREN),
+static VARS_REP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REP_CHILDREN),
     value: None,
 };
 
-pub static VARS_REP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rogramme"),
         dictgen::InsensitiveStr::Ascii("rogrammes"),
@@ -5032,12 +5032,12 @@ pub static VARS_REP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=9,
 };
 
-static VARS_REO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REO_CHILDREN),
+static VARS_REO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REO_CHILDREN),
     value: None,
 };
 
-pub static VARS_REO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rganisation"),
         dictgen::InsensitiveStr::Ascii("rganisations"),
@@ -5077,12 +5077,12 @@ pub static VARS_REO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_REM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REM_CHILDREN),
+static VARS_REM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REM_CHILDREN),
     value: None,
 };
 
-pub static VARS_REM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("odeled"),
         dictgen::InsensitiveStr::Ascii("odeling"),
@@ -5114,12 +5114,12 @@ pub static VARS_REM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=8,
 };
 
-static VARS_REL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REL_CHILDREN),
+static VARS_REL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REL_CHILDREN),
     value: None,
 };
 
-pub static VARS_REL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ativisation"),
         dictgen::InsensitiveStr::Ascii("ativisations"),
@@ -5151,12 +5151,12 @@ pub static VARS_REL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_REG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REG_CHILDREN),
+static VARS_REG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REG_CHILDREN),
     value: None,
 };
 
-pub static VARS_REG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ularisation"),
         dictgen::InsensitiveStr::Ascii("ularisations"),
@@ -5188,12 +5188,12 @@ pub static VARS_REG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_REF_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REF_CHILDREN),
+static VARS_REF_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REF_CHILDREN),
     value: None,
 };
 
-pub static VARS_REF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REF_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ueled"),
         dictgen::InsensitiveStr::Ascii("ueling"),
@@ -5209,12 +5209,12 @@ pub static VARS_REF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=7,
 };
 
-static VARS_REE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REE_CHILDREN),
+static VARS_REE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REE_CHILDREN),
     value: None,
 };
 
-pub static VARS_REE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nforce"),
         dictgen::InsensitiveStr::Ascii("nforced"),
@@ -5230,12 +5230,12 @@ pub static VARS_REE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_RED_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_RED_CHILDREN),
+static VARS_RED_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_RED_CHILDREN),
     value: None,
 };
 
-pub static VARS_RED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_RED_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ialed"),
         dictgen::InsensitiveStr::Ascii("ialing"),
@@ -5251,12 +5251,12 @@ pub static VARS_RED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=7,
 };
 
-static VARS_REC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REC_CHILDREN),
+static VARS_REC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REC_CHILDREN),
     value: None,
 };
 
-pub static VARS_REC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("apitalisation"),
         dictgen::InsensitiveStr::Ascii("apitalisations"),
@@ -5380,12 +5380,12 @@ pub static VARS_REC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=14,
 };
 
-static VARS_REA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_REA_CHILDREN),
+static VARS_REA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_REA_CHILDREN),
     value: None,
 };
 
-pub static VARS_REA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_REA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lisabilities"),
         dictgen::InsensitiveStr::Ascii("lisability"),
@@ -5467,12 +5467,12 @@ pub static VARS_REA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=12,
 };
 
-static VARS_RA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_RA_CHILDREN),
+static VARS_RA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_RA_CHILDREN),
     value: None,
 };
 
-pub static VARS_RA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_RA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cialise"),
         dictgen::InsensitiveStr::Ascii("cialises"),
@@ -5594,12 +5594,12 @@ pub static VARS_RA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=14,
 };
 
-static VARS_Q_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_Q_CHILDREN),
+static VARS_Q_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_Q_CHILDREN),
     value: None,
 };
 
-pub static VARS_Q_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_Q_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uantisation"),
         dictgen::InsensitiveStr::Ascii("uantisations"),
@@ -5653,12 +5653,12 @@ pub static VARS_Q_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen:
     range: 6..=12,
 };
 
-static VARS_P_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_P_CHILDREN),
+static VARS_P_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_P_CHILDREN),
     value: None,
 };
 
-static VARS_P_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_P_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_PA_NODE),
     None,
     None,
@@ -5687,12 +5687,12 @@ static VARS_P_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_PY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PY_CHILDREN),
+static VARS_PY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PY_CHILDREN),
     value: None,
 };
 
-pub static VARS_PY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("jama"),
         dictgen::InsensitiveStr::Ascii("jamas"),
@@ -5728,12 +5728,12 @@ pub static VARS_PY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=8,
 };
 
-static VARS_PU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PU_CHILDREN),
+static VARS_PU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PU_CHILDREN),
     value: None,
 };
 
-pub static VARS_PU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blicise"),
         dictgen::InsensitiveStr::Ascii("blicised"),
@@ -5797,12 +5797,12 @@ pub static VARS_PU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=12,
 };
 
-static VARS_PS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PS_CHILDREN),
+static VARS_PS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PS_CHILDREN),
     value: None,
 };
 
-pub static VARS_PS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ychoanalyse"),
         dictgen::InsensitiveStr::Ascii("ychoanalysed"),
@@ -5840,12 +5840,12 @@ pub static VARS_PS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 10..=13,
 };
 
-static VARS_PR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_PR_CHILDREN),
+static VARS_PR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_PR_CHILDREN),
     value: None,
 };
 
-static VARS_PR_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_PR_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_PRA_NODE),
     None,
     None,
@@ -5874,12 +5874,12 @@ static VARS_PR_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_PRO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PRO_CHILDREN),
+static VARS_PRO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PRO_CHILDREN),
     value: None,
 };
 
-pub static VARS_PRO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PRO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fessionalisation"),
         dictgen::InsensitiveStr::Ascii("fessionalisations"),
@@ -5981,12 +5981,12 @@ pub static VARS_PRO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=17,
 };
 
-static VARS_PRI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PRI_CHILDREN),
+static VARS_PRI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PRI_CHILDREN),
     value: None,
 };
 
-pub static VARS_PRI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PRI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("maeval"),
         dictgen::InsensitiveStr::Ascii("maevally"),
@@ -6062,12 +6062,12 @@ pub static VARS_PRI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=12,
 };
 
-static VARS_PRE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PRE_CHILDREN),
+static VARS_PRE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PRE_CHILDREN),
     value: None,
 };
 
-pub static VARS_PRE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PRE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("conise"),
         dictgen::InsensitiveStr::Ascii("conised"),
@@ -6141,12 +6141,12 @@ pub static VARS_PRE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=12,
 };
 
-static VARS_PRA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PRA_CHILDREN),
+static VARS_PRA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PRA_CHILDREN),
     value: None,
 };
 
-pub static VARS_PRA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PRA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cticed"),
         dictgen::InsensitiveStr::Ascii("cticer"),
@@ -6166,12 +6166,12 @@ pub static VARS_PRA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=7,
 };
 
-static VARS_PO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_PO_CHILDREN),
+static VARS_PO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_PO_CHILDREN),
     value: None,
 };
 
-static VARS_PO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_PO_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -6200,12 +6200,12 @@ static VARS_PO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_POU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_POU_CHILDREN),
+static VARS_POU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_POU_CHILDREN),
     value: None,
 };
 
-pub static VARS_POU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_POU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rer"),
         dictgen::InsensitiveStr::Ascii("rers"),
@@ -6217,12 +6217,12 @@ pub static VARS_POU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=4,
 };
 
-static VARS_POR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_POR_CHILDREN),
+static VARS_POR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_POR_CHILDREN),
     value: None,
 };
 
-pub static VARS_POR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_POR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ers"),
@@ -6234,12 +6234,12 @@ pub static VARS_POR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=3,
 };
 
-static VARS_POP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_POP_CHILDREN),
+static VARS_POP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_POP_CHILDREN),
     value: None,
 };
 
-pub static VARS_POP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_POP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ularisation"),
         dictgen::InsensitiveStr::Ascii("ularisations"),
@@ -6279,12 +6279,12 @@ pub static VARS_POP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_POM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_POM_CHILDREN),
+static VARS_POM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_POM_CHILDREN),
     value: None,
 };
 
-pub static VARS_POM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_POM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("meled"),
         dictgen::InsensitiveStr::Ascii("meling"),
@@ -6300,12 +6300,12 @@ pub static VARS_POM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=7,
 };
 
-static VARS_POL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_POL_CHILDREN),
+static VARS_POL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_POL_CHILDREN),
     value: None,
 };
 
-pub static VARS_POL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_POL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arisable"),
         dictgen::InsensitiveStr::Ascii("arisables"),
@@ -6417,12 +6417,12 @@ pub static VARS_POL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=12,
 };
 
-static VARS_POE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_POE_CHILDREN),
+static VARS_POE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_POE_CHILDREN),
     value: None,
 };
 
-pub static VARS_POE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_POE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ticise"),
         dictgen::InsensitiveStr::Ascii("ticised"),
@@ -6462,12 +6462,12 @@ pub static VARS_POE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=8,
 };
 
-static VARS_PL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_PL_CHILDREN),
+static VARS_PL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_PL_CHILDREN),
     value: None,
 };
 
-static VARS_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_PL_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_PLA_NODE),
     None,
     None,
@@ -6496,12 +6496,12 @@ static VARS_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_PLU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PLU_CHILDREN),
+static VARS_PLU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PLU_CHILDREN),
     value: None,
 };
 
-pub static VARS_PLU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PLU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ralisation"),
         dictgen::InsensitiveStr::Ascii("ralisations"),
@@ -6533,12 +6533,12 @@ pub static VARS_PLU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_PLO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PLO_CHILDREN),
+static VARS_PLO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PLO_CHILDREN),
     value: None,
 };
 
-pub static VARS_PLO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PLO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ugh"),
         dictgen::InsensitiveStr::Ascii("ughable"),
@@ -6590,12 +6590,12 @@ pub static VARS_PLO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 1..=9,
 };
 
-static VARS_PLA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PLA_CHILDREN),
+static VARS_PLA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PLA_CHILDREN),
     value: None,
 };
 
-pub static VARS_PLA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PLA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("giarise"),
         dictgen::InsensitiveStr::Ascii("giarised"),
@@ -6691,12 +6691,12 @@ pub static VARS_PLA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=12,
 };
 
-static VARS_PI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PI_CHILDREN),
+static VARS_PI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PI_CHILDREN),
     value: None,
 };
 
-pub static VARS_PI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aster"),
         dictgen::InsensitiveStr::Ascii("asters"),
@@ -6712,12 +6712,12 @@ pub static VARS_PI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=6,
 };
 
-static VARS_PH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PH_CHILDREN),
+static VARS_PH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PH_CHILDREN),
     value: None,
 };
 
-pub static VARS_PH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilosophise"),
         dictgen::InsensitiveStr::Ascii("ilosophised"),
@@ -6793,12 +6793,12 @@ pub static VARS_PH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=15,
 };
 
-static VARS_PE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_PE_CHILDREN),
+static VARS_PE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_PE_CHILDREN),
     value: None,
 };
 
-static VARS_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_PE_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -6827,12 +6827,12 @@ static VARS_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_PER_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PER_CHILDREN),
+static VARS_PER_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PER_CHILDREN),
     value: None,
 };
 
-pub static VARS_PER_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PER_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iled"),
         dictgen::InsensitiveStr::Ascii("iling"),
@@ -6880,12 +6880,12 @@ pub static VARS_PER_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=13,
 };
 
-static VARS_PEN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PEN_CHILDREN),
+static VARS_PEN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PEN_CHILDREN),
     value: None,
 };
 
-pub static VARS_PEN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PEN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alisation"),
         dictgen::InsensitiveStr::Ascii("alisations"),
@@ -6929,12 +6929,12 @@ pub static VARS_PEN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_PED_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PED_CHILDREN),
+static VARS_PED_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PED_CHILDREN),
     value: None,
 };
 
-pub static VARS_PED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PED_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agog"),
         dictgen::InsensitiveStr::Ascii("agogs"),
@@ -7010,12 +7010,12 @@ pub static VARS_PED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=15,
 };
 
-static VARS_PA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_PA_CHILDREN),
+static VARS_PA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_PA_CHILDREN),
     value: None,
 };
 
-static VARS_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_PA_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -7044,12 +7044,12 @@ static VARS_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_PAU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PAU_CHILDREN),
+static VARS_PAU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PAU_CHILDREN),
     value: None,
 };
 
-pub static VARS_PAU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PAU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("perisation"),
         dictgen::InsensitiveStr::Ascii("perisations"),
@@ -7081,12 +7081,12 @@ pub static VARS_PAU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_PAT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PAT_CHILDREN),
+static VARS_PAT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PAT_CHILDREN),
     value: None,
 };
 
-pub static VARS_PAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PAT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ronise"),
         dictgen::InsensitiveStr::Ascii("ronised"),
@@ -7134,12 +7134,12 @@ pub static VARS_PAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=13,
 };
 
-static VARS_PAS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PAS_CHILDREN),
+static VARS_PAS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PAS_CHILDREN),
     value: None,
 };
 
-pub static VARS_PAS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PAS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sivisation"),
         dictgen::InsensitiveStr::Ascii("sivization"),
@@ -7183,12 +7183,12 @@ pub static VARS_PAS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_PAR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PAR_CHILDREN),
+static VARS_PAR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PAR_CHILDREN),
     value: None,
 };
 
-pub static VARS_PAR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PAR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alyse"),
         dictgen::InsensitiveStr::Ascii("alysed"),
@@ -7298,12 +7298,12 @@ pub static VARS_PAR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=15,
 };
 
-static VARS_PAN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PAN_CHILDREN),
+static VARS_PAN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PAN_CHILDREN),
     value: None,
 };
 
-pub static VARS_PAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PAN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egyrise"),
         dictgen::InsensitiveStr::Ascii("egyrised"),
@@ -7347,12 +7347,12 @@ pub static VARS_PAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=9,
 };
 
-static VARS_PAL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PAL_CHILDREN),
+static VARS_PAL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PAL_CHILDREN),
     value: None,
 };
 
-pub static VARS_PAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PAL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aeoclimatologies"),
         dictgen::InsensitiveStr::Ascii("aeoclimatology"),
@@ -7428,12 +7428,12 @@ pub static VARS_PAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=16,
 };
 
-static VARS_PAJ_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PAJ_CHILDREN),
+static VARS_PAJ_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PAJ_CHILDREN),
     value: None,
 };
 
-pub static VARS_PAJ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PAJ_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ama"),
         dictgen::InsensitiveStr::Ascii("amas"),
@@ -7445,12 +7445,12 @@ pub static VARS_PAJ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=4,
 };
 
-static VARS_PAE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_PAE_CHILDREN),
+static VARS_PAE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_PAE_CHILDREN),
     value: None,
 };
 
-pub static VARS_PAE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_PAE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("derast"),
         dictgen::InsensitiveStr::Ascii("derasts"),
@@ -7478,12 +7478,12 @@ pub static VARS_PAE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_O_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_O_CHILDREN),
+static VARS_O_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_O_CHILDREN),
     value: None,
 };
 
-static VARS_O_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_O_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     Some(&VARS_OB_NODE),
     Some(&VARS_OC_NODE),
@@ -7512,12 +7512,12 @@ static VARS_O_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_OX_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OX_CHILDREN),
+static VARS_OX_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OX_CHILDREN),
     value: None,
 };
 
-pub static VARS_OX_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OX_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("idisable"),
         dictgen::InsensitiveStr::Ascii("idisables"),
@@ -7569,12 +7569,12 @@ pub static VARS_OX_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=10,
 };
 
-static VARS_OV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OV_CHILDREN),
+static VARS_OV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OV_CHILDREN),
     value: None,
 };
 
-pub static VARS_OV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ercapitalise"),
         dictgen::InsensitiveStr::Ascii("ercapitalised"),
@@ -7670,12 +7670,12 @@ pub static VARS_OV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 11..=17,
 };
 
-static VARS_OU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OU_CHILDREN),
+static VARS_OU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OU_CHILDREN),
     value: None,
 };
 
-pub static VARS_OU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rang"),
         dictgen::InsensitiveStr::Ascii("rangs"),
@@ -7703,12 +7703,12 @@ pub static VARS_OU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=12,
 };
 
-static VARS_OS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OS_CHILDREN),
+static VARS_OS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OS_CHILDREN),
     value: None,
 };
 
-pub static VARS_OS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tracise"),
         dictgen::InsensitiveStr::Ascii("tracised"),
@@ -7732,12 +7732,12 @@ pub static VARS_OS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=9,
 };
 
-static VARS_OR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OR_CHILDREN),
+static VARS_OR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OR_CHILDREN),
     value: None,
 };
 
-pub static VARS_OR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gandie"),
         dictgen::InsensitiveStr::Ascii("gandy"),
@@ -7849,12 +7849,12 @@ pub static VARS_OR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=17,
 };
 
-static VARS_OP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OP_CHILDREN),
+static VARS_OP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OP_CHILDREN),
     value: None,
 };
 
-pub static VARS_OP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("timisation"),
         dictgen::InsensitiveStr::Ascii("timisations"),
@@ -7894,12 +7894,12 @@ pub static VARS_OP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=11,
 };
 
-static VARS_OM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OM_CHILDREN),
+static VARS_OM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OM_CHILDREN),
     value: None,
 };
 
-pub static VARS_OM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("elet"),
         dictgen::InsensitiveStr::Ascii("elets"),
@@ -7911,12 +7911,12 @@ pub static VARS_OM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=5,
 };
 
-static VARS_OF_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OF_CHILDREN),
+static VARS_OF_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OF_CHILDREN),
     value: None,
 };
 
-pub static VARS_OF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OF_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("fence"),
         dictgen::InsensitiveStr::Ascii("fences"),
@@ -7932,12 +7932,12 @@ pub static VARS_OF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=6,
 };
 
-static VARS_OE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OE_CHILDREN),
+static VARS_OE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OE_CHILDREN),
     value: None,
 };
 
-pub static VARS_OE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cumenism"),
         dictgen::InsensitiveStr::Ascii("dema"),
@@ -7977,12 +7977,12 @@ pub static VARS_OE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=10,
 };
 
-static VARS_OD_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OD_CHILDREN),
+static VARS_OD_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OD_CHILDREN),
     value: None,
 };
 
-pub static VARS_OD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OD_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orless"),
@@ -8010,12 +8010,12 @@ pub static VARS_OD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=10,
 };
 
-static VARS_OC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OC_CHILDREN),
+static VARS_OC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OC_CHILDREN),
     value: None,
 };
 
-pub static VARS_OC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("her"),
         dictgen::InsensitiveStr::Ascii("hered"),
@@ -8053,12 +8053,12 @@ pub static VARS_OC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=9,
 };
 
-static VARS_OB_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_OB_CHILDREN),
+static VARS_OB_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_OB_CHILDREN),
     value: None,
 };
 
-pub static VARS_OB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_OB_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("jectivise"),
         dictgen::InsensitiveStr::Ascii("jectivised"),
@@ -8082,12 +8082,12 @@ pub static VARS_OB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 9..=11,
 };
 
-static VARS_N_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_N_CHILDREN),
+static VARS_N_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_N_CHILDREN),
     value: None,
 };
 
-static VARS_N_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_N_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_NA_NODE),
     None,
     None,
@@ -8116,12 +8116,12 @@ static VARS_N_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_NO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NO_CHILDREN),
+static VARS_NO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NO_CHILDREN),
     value: None,
 };
 
-pub static VARS_NO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rmalisation"),
         dictgen::InsensitiveStr::Ascii("rmalisations"),
@@ -8205,12 +8205,12 @@ pub static VARS_NO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=12,
 };
 
-static VARS_NI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NI_CHILDREN),
+static VARS_NI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NI_CHILDREN),
     value: None,
 };
 
-pub static VARS_NI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("te"),
         dictgen::InsensitiveStr::Ascii("ter"),
@@ -8234,12 +8234,12 @@ pub static VARS_NI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=12,
 };
 
-static VARS_NE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_NE_CHILDREN),
+static VARS_NE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_NE_CHILDREN),
     value: None,
 };
 
-static VARS_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_NE_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     Some(&VARS_NEB_NODE),
     None,
@@ -8268,12 +8268,12 @@ static VARS_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_NEU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NEU_CHILDREN),
+static VARS_NEU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NEU_CHILDREN),
     value: None,
 };
 
-pub static VARS_NEU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NEU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tralisation"),
         dictgen::InsensitiveStr::Ascii("tralisations"),
@@ -8313,12 +8313,12 @@ pub static VARS_NEU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_NET_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NET_CHILDREN),
+static VARS_NET_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NET_CHILDREN),
     value: None,
 };
 
-pub static VARS_NET_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NET_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("t"),
         dictgen::InsensitiveStr::Ascii("ts"),
@@ -8330,12 +8330,12 @@ pub static VARS_NET_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 1..=2,
 };
 
-static VARS_NEO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NEO_CHILDREN),
+static VARS_NEO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NEO_CHILDREN),
     value: None,
 };
 
-pub static VARS_NEO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NEO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logise"),
         dictgen::InsensitiveStr::Ascii("logised"),
@@ -8359,12 +8359,12 @@ pub static VARS_NEO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_NEI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NEI_CHILDREN),
+static VARS_NEI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NEI_CHILDREN),
     value: None,
 };
 
-pub static VARS_NEI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NEI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ghbor"),
         dictgen::InsensitiveStr::Ascii("ghbored"),
@@ -8420,12 +8420,12 @@ pub static VARS_NEI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=14,
 };
 
-static VARS_NEG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NEG_CHILDREN),
+static VARS_NEG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NEG_CHILDREN),
     value: None,
 };
 
-pub static VARS_NEG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NEG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lig"),
         dictgen::InsensitiveStr::Ascii("ligs"),
@@ -8437,12 +8437,12 @@ pub static VARS_NEG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=4,
 };
 
-static VARS_NEB_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NEB_CHILDREN),
+static VARS_NEB_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NEB_CHILDREN),
     value: None,
 };
 
-pub static VARS_NEB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NEB_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ulise"),
         dictgen::InsensitiveStr::Ascii("ulised"),
@@ -8474,12 +8474,12 @@ pub static VARS_NEB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=7,
 };
 
-static VARS_NA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_NA_CHILDREN),
+static VARS_NA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_NA_CHILDREN),
     value: None,
 };
 
-pub static VARS_NA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_NA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nometer"),
         dictgen::InsensitiveStr::Ascii("nometers"),
@@ -8583,12 +8583,12 @@ pub static VARS_NA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=14,
 };
 
-static VARS_M_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_M_CHILDREN),
+static VARS_M_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_M_CHILDREN),
     value: None,
 };
 
-static VARS_M_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_M_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_MA_NODE),
     None,
     None,
@@ -8617,12 +8617,12 @@ static VARS_M_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_MY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MY_CHILDREN),
+static VARS_MY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MY_CHILDREN),
     value: None,
 };
 
-pub static VARS_MY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thicise"),
         dictgen::InsensitiveStr::Ascii("thicised"),
@@ -8682,12 +8682,12 @@ pub static VARS_MY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=11,
 };
 
-static VARS_MU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MU_CHILDREN),
+static VARS_MU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MU_CHILDREN),
     value: None,
 };
 
-pub static VARS_MU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stache"),
         dictgen::InsensitiveStr::Ascii("stached"),
@@ -8701,12 +8701,12 @@ pub static VARS_MU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=7,
 };
 
-static VARS_MO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_MO_CHILDREN),
+static VARS_MO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_MO_CHILDREN),
     value: None,
 };
 
-static VARS_MO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_MO_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     Some(&VARS_MOB_NODE),
     None,
@@ -8735,23 +8735,23 @@ static VARS_MO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_MOV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOV_CHILDREN),
+static VARS_MOV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOV_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("eability")],
     values: &[&[(0b00001, &ENTRY_MOVABILITY_2120736134131484989)]],
     range: 8..=8,
 };
 
-static VARS_MOU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOU_CHILDREN),
+static VARS_MOU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOU_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ld"),
         dictgen::InsensitiveStr::Ascii("lded"),
@@ -8797,12 +8797,12 @@ pub static VARS_MOU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=7,
 };
 
-static VARS_MOT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOT_CHILDREN),
+static VARS_MOT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOT_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orisation"),
         dictgen::InsensitiveStr::Ascii("orisations"),
@@ -8834,12 +8834,12 @@ pub static VARS_MOT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_MOR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOR_CHILDREN),
+static VARS_MOR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOR_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alisation"),
         dictgen::InsensitiveStr::Ascii("alisations"),
@@ -8887,12 +8887,12 @@ pub static VARS_MOR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=11,
 };
 
-static VARS_MON_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MON_CHILDREN),
+static VARS_MON_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MON_CHILDREN),
     value: None,
 };
 
-pub static VARS_MON_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MON_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ecious"),
         dictgen::InsensitiveStr::Ascii("etisation"),
@@ -8986,12 +8986,12 @@ pub static VARS_MON_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=12,
 };
 
-static VARS_MOL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOL_CHILDREN),
+static VARS_MOL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOL_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("d"),
         dictgen::InsensitiveStr::Ascii("ded"),
@@ -9037,12 +9037,12 @@ pub static VARS_MOL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 1..=6,
 };
 
-static VARS_MOI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOI_CHILDREN),
+static VARS_MOI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOI_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sturise"),
         dictgen::InsensitiveStr::Ascii("sturised"),
@@ -9074,23 +9074,23 @@ pub static VARS_MOI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=9,
 };
 
-static VARS_MOG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOG_CHILDREN),
+static VARS_MOG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOG_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("gy")],
     values: &[&[(0b10011, &ENTRY_MOGGY_7403358484289979778)]],
     range: 2..=2,
 };
 
-static VARS_MOD_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOD_CHILDREN),
+static VARS_MOD_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOD_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOD_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eler"),
@@ -9150,12 +9150,12 @@ pub static VARS_MOD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=11,
 };
 
-static VARS_MOB_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MOB_CHILDREN),
+static VARS_MOB_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MOB_CHILDREN),
     value: None,
 };
 
-pub static VARS_MOB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MOB_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ilisable"),
         dictgen::InsensitiveStr::Ascii("ilisabler"),
@@ -9211,12 +9211,12 @@ pub static VARS_MOB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_MI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_MI_CHILDREN),
+static VARS_MI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_MI_CHILDREN),
     value: None,
 };
 
-static VARS_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_MI_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_MIA_NODE),
     None,
     Some(&VARS_MIC_NODE),
@@ -9245,12 +9245,12 @@ static VARS_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_MIT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MIT_CHILDREN),
+static VARS_MIT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MIT_CHILDREN),
     value: None,
 };
 
-pub static VARS_MIT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MIT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("ered"),
@@ -9274,12 +9274,12 @@ pub static VARS_MIT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=5,
 };
 
-static VARS_MIS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MIS_CHILDREN),
+static VARS_MIS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MIS_CHILDREN),
     value: None,
 };
 
-pub static VARS_MIS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MIS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("behavior"),
         dictgen::InsensitiveStr::Ascii("behaviors"),
@@ -9315,12 +9315,12 @@ pub static VARS_MIS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_MIN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MIN_CHILDREN),
+static VARS_MIN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MIN_CHILDREN),
     value: None,
 };
 
-pub static VARS_MIN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MIN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eralisation"),
         dictgen::InsensitiveStr::Ascii("eralisations"),
@@ -9410,12 +9410,12 @@ pub static VARS_MIN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=13,
 };
 
-static VARS_MIL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MIL_CHILDREN),
+static VARS_MIL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MIL_CHILDREN),
     value: None,
 };
 
-pub static VARS_MIL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MIL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("itarisation"),
         dictgen::InsensitiveStr::Ascii("itarisations"),
@@ -9467,12 +9467,12 @@ pub static VARS_MIL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_MIC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MIC_CHILDREN),
+static VARS_MIC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MIC_CHILDREN),
     value: None,
 };
 
-pub static VARS_MIC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MIC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rometre"),
         dictgen::InsensitiveStr::Ascii("rometres"),
@@ -9492,12 +9492,12 @@ pub static VARS_MIC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=18,
 };
 
-static VARS_MIA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MIA_CHILDREN),
+static VARS_MIA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MIA_CHILDREN),
     value: None,
 };
 
-pub static VARS_MIA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MIA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ow"),
         dictgen::InsensitiveStr::Ascii("owed"),
@@ -9513,12 +9513,12 @@ pub static VARS_MIA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=5,
 };
 
-static VARS_ME_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_ME_CHILDREN),
+static VARS_ME_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_ME_CHILDREN),
     value: None,
 };
 
-static VARS_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_ME_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_MEA_NODE),
     None,
     Some(&VARS_MEC_NODE),
@@ -9547,12 +9547,12 @@ static VARS_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_MET_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MET_CHILDREN),
+static VARS_MET_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MET_CHILDREN),
     value: None,
 };
 
-pub static VARS_MET_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MET_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abolisable"),
         dictgen::InsensitiveStr::Ascii("abolisables"),
@@ -9656,12 +9656,12 @@ pub static VARS_MET_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=11,
 };
 
-static VARS_MES_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MES_CHILDREN),
+static VARS_MES_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MES_CHILDREN),
     value: None,
 };
 
-pub static VARS_MES_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MES_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("merise"),
         dictgen::InsensitiveStr::Ascii("merised"),
@@ -9685,12 +9685,12 @@ pub static VARS_MES_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_MER_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MER_CHILDREN),
+static VARS_MER_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MER_CHILDREN),
     value: None,
 };
 
-pub static VARS_MER_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MER_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cerise"),
         dictgen::InsensitiveStr::Ascii("cerised"),
@@ -9714,12 +9714,12 @@ pub static VARS_MER_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_MEN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MEN_CHILDREN),
+static VARS_MEN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MEN_CHILDREN),
     value: None,
 };
 
-pub static VARS_MEN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MEN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ad"),
         dictgen::InsensitiveStr::Ascii("adic"),
@@ -9733,12 +9733,12 @@ pub static VARS_MEN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=4,
 };
 
-static VARS_MEM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MEM_CHILDREN),
+static VARS_MEM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MEM_CHILDREN),
     value: None,
 };
 
-pub static VARS_MEM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MEM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orialise"),
         dictgen::InsensitiveStr::Ascii("orialised"),
@@ -9794,12 +9794,12 @@ pub static VARS_MEM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_MEL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MEL_CHILDREN),
+static VARS_MEL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MEL_CHILDREN),
     value: None,
 };
 
-pub static VARS_MEL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MEL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("odise"),
         dictgen::InsensitiveStr::Ascii("odised"),
@@ -9839,12 +9839,12 @@ pub static VARS_MEL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=12,
 };
 
-static VARS_MEG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MEG_CHILDREN),
+static VARS_MEG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MEG_CHILDREN),
     value: None,
 };
 
-pub static VARS_MEG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MEG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agramme"),
         dictgen::InsensitiveStr::Ascii("agrammes"),
@@ -9856,12 +9856,12 @@ pub static VARS_MEG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=8,
 };
 
-static VARS_MED_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MED_CHILDREN),
+static VARS_MED_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MED_CHILDREN),
     value: None,
 };
 
-pub static VARS_MED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MED_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alist"),
         dictgen::InsensitiveStr::Ascii("alists"),
@@ -9881,12 +9881,12 @@ pub static VARS_MED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=7,
 };
 
-static VARS_MEC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MEC_CHILDREN),
+static VARS_MEC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MEC_CHILDREN),
     value: None,
 };
 
-pub static VARS_MEC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MEC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hanisation"),
         dictgen::InsensitiveStr::Ascii("hanisations"),
@@ -9926,12 +9926,12 @@ pub static VARS_MEC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_MEA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MEA_CHILDREN),
+static VARS_MEA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MEA_CHILDREN),
     value: None,
 };
 
-pub static VARS_MEA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MEA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ger"),
         dictgen::InsensitiveStr::Ascii("gerrer"),
@@ -9951,12 +9951,12 @@ pub static VARS_MEA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=7,
 };
 
-static VARS_MA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_MA_CHILDREN),
+static VARS_MA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_MA_CHILDREN),
     value: None,
 };
 
-static VARS_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_MA_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -9985,12 +9985,12 @@ static VARS_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_MAX_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MAX_CHILDREN),
+static VARS_MAX_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MAX_CHILDREN),
     value: None,
 };
 
-pub static VARS_MAX_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MAX_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("imisation"),
         dictgen::InsensitiveStr::Ascii("imisations"),
@@ -10030,12 +10030,12 @@ pub static VARS_MAX_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_MAT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MAT_CHILDREN),
+static VARS_MAT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MAT_CHILDREN),
     value: None,
 };
 
-pub static VARS_MAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MAT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("erialisation"),
         dictgen::InsensitiveStr::Ascii("erialisations"),
@@ -10069,12 +10069,12 @@ pub static VARS_MAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=13,
 };
 
-static VARS_MAR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MAR_CHILDREN),
+static VARS_MAR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MAR_CHILDREN),
     value: None,
 };
 
-pub static VARS_MAR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MAR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bleise"),
         dictgen::InsensitiveStr::Ascii("bleised"),
@@ -10166,12 +10166,12 @@ pub static VARS_MAR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=13,
 };
 
-static VARS_MAN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MAN_CHILDREN),
+static VARS_MAN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MAN_CHILDREN),
     value: None,
 };
 
-pub static VARS_MAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MAN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("daean"),
         dictgen::InsensitiveStr::Ascii("daeans"),
@@ -10249,12 +10249,12 @@ pub static VARS_MAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=14,
 };
 
-static VARS_MAG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_MAG_CHILDREN),
+static VARS_MAG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_MAG_CHILDREN),
     value: None,
 };
 
-pub static VARS_MAG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_MAG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("netisation"),
         dictgen::InsensitiveStr::Ascii("netisations"),
@@ -10286,12 +10286,12 @@ pub static VARS_MAG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_L_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_L_CHILDREN),
+static VARS_L_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_L_CHILDREN),
     value: None,
 };
 
-static VARS_L_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_L_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_LA_NODE),
     None,
     None,
@@ -10320,12 +10320,12 @@ static VARS_L_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_LY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LY_CHILDREN),
+static VARS_LY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LY_CHILDREN),
     value: None,
 };
 
-pub static VARS_LY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ophilisation"),
         dictgen::InsensitiveStr::Ascii("ophilisations"),
@@ -10357,12 +10357,12 @@ pub static VARS_LY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 8..=13,
 };
 
-static VARS_LU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LU_CHILDREN),
+static VARS_LU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LU_CHILDREN),
     value: None,
 };
 
-pub static VARS_LU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pines"),
         dictgen::InsensitiveStr::Ascii("ster"),
@@ -10404,12 +10404,12 @@ pub static VARS_LU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 1..=11,
 };
 
-static VARS_LO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LO_CHILDREN),
+static VARS_LO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LO_CHILDREN),
     value: None,
 };
 
-pub static VARS_LO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("botomise"),
         dictgen::InsensitiveStr::Ascii("botomised"),
@@ -10507,12 +10507,12 @@ pub static VARS_LO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=11,
 };
 
-static VARS_LI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_LI_CHILDREN),
+static VARS_LI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_LI_CHILDREN),
     value: None,
 };
 
-static VARS_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_LI_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     Some(&VARS_LIB_NODE),
     Some(&VARS_LIC_NODE),
@@ -10541,23 +10541,23 @@ static VARS_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_LIV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIV_CHILDREN),
+static VARS_LIV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIV_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("able")],
     values: &[&[(0b11001, &ENTRY_LIVABLE_13408079841838673902)]],
     range: 4..=4,
 };
 
-static VARS_LIT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIT_CHILDREN),
+static VARS_LIT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIT_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("er"),
         dictgen::InsensitiveStr::Ascii("eralise"),
@@ -10589,12 +10589,12 @@ pub static VARS_LIT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=9,
 };
 
-static VARS_LIS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIS_CHILDREN),
+static VARS_LIS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIS_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("someness"),
         dictgen::InsensitiveStr::Ascii("somenesses"),
@@ -10610,12 +10610,12 @@ pub static VARS_LIS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=10,
 };
 
-static VARS_LIQ_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIQ_CHILDREN),
+static VARS_LIQ_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIQ_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIQ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIQ_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("uidise"),
         dictgen::InsensitiveStr::Ascii("uidised"),
@@ -10651,12 +10651,12 @@ pub static VARS_LIQ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_LIO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIO_CHILDREN),
+static VARS_LIO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIO_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nisation"),
         dictgen::InsensitiveStr::Ascii("nisations"),
@@ -10696,12 +10696,12 @@ pub static VARS_LIO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=9,
 };
 
-static VARS_LIN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIN_CHILDREN),
+static VARS_LIN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIN_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("earise"),
         dictgen::InsensitiveStr::Ascii("earised"),
@@ -10725,12 +10725,12 @@ pub static VARS_LIN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_LIK_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIK_CHILDREN),
+static VARS_LIK_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIK_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIK_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIK_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abilities"),
         dictgen::InsensitiveStr::Ascii("ability"),
@@ -10746,12 +10746,12 @@ pub static VARS_LIK_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=10,
 };
 
-static VARS_LIC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIC_CHILDREN),
+static VARS_LIC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIC_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -10773,12 +10773,12 @@ pub static VARS_LIC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=6,
 };
 
-static VARS_LIB_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LIB_CHILDREN),
+static VARS_LIB_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LIB_CHILDREN),
     value: None,
 };
 
-pub static VARS_LIB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LIB_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eler"),
@@ -10846,12 +10846,12 @@ pub static VARS_LIB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=12,
 };
 
-static VARS_LE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LE_CHILDREN),
+static VARS_LE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LE_CHILDREN),
     value: None,
 };
 
-pub static VARS_LE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("arnt"),
         dictgen::InsensitiveStr::Ascii("galisation"),
@@ -10941,12 +10941,12 @@ pub static VARS_LE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=13,
 };
 
-static VARS_LA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_LA_CHILDREN),
+static VARS_LA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_LA_CHILDREN),
     value: None,
 };
 
-pub static VARS_LA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_LA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("beled"),
         dictgen::InsensitiveStr::Ascii("beler"),
@@ -11078,12 +11078,12 @@ pub static VARS_LA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=12,
 };
 
-static VARS_K_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_K_CHILDREN),
+static VARS_K_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_K_CHILDREN),
     value: None,
 };
 
-pub static VARS_K_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_K_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("enneled"),
         dictgen::InsensitiveStr::Ascii("enneling"),
@@ -11187,12 +11187,12 @@ pub static VARS_K_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen:
     range: 7..=14,
 };
 
-static VARS_J_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_J_CHILDREN),
+static VARS_J_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_J_CHILDREN),
     value: None,
 };
 
-pub static VARS_J_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_J_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ailor"),
         dictgen::InsensitiveStr::Ascii("ailors"),
@@ -11278,12 +11278,12 @@ pub static VARS_J_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen:
     range: 3..=11,
 };
 
-static VARS_I_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_I_CHILDREN),
+static VARS_I_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_I_CHILDREN),
     value: None,
 };
 
-static VARS_I_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_I_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -11312,12 +11312,12 @@ static VARS_I_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_IT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_IT_CHILDREN),
+static VARS_IT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_IT_CHILDREN),
     value: None,
 };
 
-pub static VARS_IT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_IT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alicisation"),
         dictgen::InsensitiveStr::Ascii("alicisations"),
@@ -11373,12 +11373,12 @@ pub static VARS_IT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=12,
 };
 
-static VARS_IS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_IS_CHILDREN),
+static VARS_IS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_IS_CHILDREN),
     value: None,
 };
 
-pub static VARS_IS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_IS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chaemia"),
         dictgen::InsensitiveStr::Ascii("chaemias"),
@@ -11398,12 +11398,12 @@ pub static VARS_IS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=8,
 };
 
-static VARS_IO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_IO_CHILDREN),
+static VARS_IO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_IO_CHILDREN),
     value: None,
 };
 
-pub static VARS_IO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_IO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dise"),
         dictgen::InsensitiveStr::Ascii("dised"),
@@ -11475,12 +11475,12 @@ pub static VARS_IO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=9,
 };
 
-static VARS_IN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_IN_CHILDREN),
+static VARS_IN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_IN_CHILDREN),
     value: None,
 };
 
-static VARS_IN_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_IN_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     Some(&VARS_INC_NODE),
@@ -11509,12 +11509,12 @@ static VARS_IN_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_INT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_INT_CHILDREN),
+static VARS_INT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_INT_CHILDREN),
     value: None,
 };
 
-pub static VARS_INT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_INT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ellectualise"),
         dictgen::InsensitiveStr::Ascii("ellectualised"),
@@ -11610,12 +11610,12 @@ pub static VARS_INT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=18,
 };
 
-static VARS_INS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_INS_CHILDREN),
+static VARS_INS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_INS_CHILDREN),
     value: None,
 };
 
-pub static VARS_INS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_INS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tal"),
         dictgen::InsensitiveStr::Ascii("tallment"),
@@ -11663,12 +11663,12 @@ pub static VARS_INS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=18,
 };
 
-static VARS_INI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_INI_CHILDREN),
+static VARS_INI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_INI_CHILDREN),
     value: None,
 };
 
-pub static VARS_INI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_INI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tialed"),
         dictgen::InsensitiveStr::Ascii("tialing"),
@@ -11708,12 +11708,12 @@ pub static VARS_INI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=12,
 };
 
-static VARS_INF_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_INF_CHILDREN),
+static VARS_INF_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_INF_CHILDREN),
     value: None,
 };
 
-pub static VARS_INF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_INF_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lexion"),
         dictgen::InsensitiveStr::Ascii("lexions"),
@@ -11725,12 +11725,12 @@ pub static VARS_INF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=7,
 };
 
-static VARS_IND_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_IND_CHILDREN),
+static VARS_IND_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_IND_CHILDREN),
     value: None,
 };
 
-pub static VARS_IND_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_IND_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ianisation"),
         dictgen::InsensitiveStr::Ascii("ianise"),
@@ -11814,12 +11814,12 @@ pub static VARS_IND_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=15,
 };
 
-static VARS_INC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_INC_CHILDREN),
+static VARS_INC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_INC_CHILDREN),
     value: None,
 };
 
-pub static VARS_INC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_INC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("entivise"),
         dictgen::InsensitiveStr::Ascii("entivised"),
@@ -11855,12 +11855,12 @@ pub static VARS_INC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=10,
 };
 
-static VARS_IM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_IM_CHILDREN),
+static VARS_IM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_IM_CHILDREN),
     value: None,
 };
 
-pub static VARS_IM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_IM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bedment"),
         dictgen::InsensitiveStr::Ascii("bedments"),
@@ -11972,12 +11972,12 @@ pub static VARS_IM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=14,
 };
 
-static VARS_ID_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ID_CHILDREN),
+static VARS_ID_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ID_CHILDREN),
     value: None,
 };
 
-pub static VARS_ID_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ID_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ealisation"),
         dictgen::InsensitiveStr::Ascii("ealisations"),
@@ -12041,12 +12041,12 @@ pub static VARS_ID_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=11,
 };
 
-static VARS_H_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_H_CHILDREN),
+static VARS_H_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_H_CHILDREN),
     value: None,
 };
 
-static VARS_H_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_H_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_HA_NODE),
     None,
     None,
@@ -12075,12 +12075,12 @@ static VARS_H_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_HY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HY_CHILDREN),
+static VARS_HY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HY_CHILDREN),
     value: None,
 };
 
-pub static VARS_HY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bridisable"),
         dictgen::InsensitiveStr::Ascii("bridisabler"),
@@ -12198,12 +12198,12 @@ pub static VARS_HY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=12,
 };
 
-static VARS_HU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HU_CHILDREN),
+static VARS_HU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HU_CHILDREN),
     value: None,
 };
 
-pub static VARS_HU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("manisation"),
         dictgen::InsensitiveStr::Ascii("manisations"),
@@ -12273,12 +12273,12 @@ pub static VARS_HU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=14,
 };
 
-static VARS_HO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_HO_CHILDREN),
+static VARS_HO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_HO_CHILDREN),
     value: None,
 };
 
-static VARS_HO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_HO_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -12307,12 +12307,12 @@ static VARS_HO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_HOS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HOS_CHILDREN),
+static VARS_HOS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HOS_CHILDREN),
     value: None,
 };
 
-pub static VARS_HOS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HOS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pitalisation"),
         dictgen::InsensitiveStr::Ascii("pitalisations"),
@@ -12344,12 +12344,12 @@ pub static VARS_HOS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=13,
 };
 
-static VARS_HOO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HOO_CHILDREN),
+static VARS_HOO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HOO_CHILDREN),
     value: None,
 };
 
-pub static VARS_HOO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HOO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rah"),
         dictgen::InsensitiveStr::Ascii("rahs"),
@@ -12361,12 +12361,12 @@ pub static VARS_HOO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=4,
 };
 
-static VARS_HON_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HON_CHILDREN),
+static VARS_HON_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HON_CHILDREN),
     value: None,
 };
 
-pub static VARS_HON_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HON_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orable"),
@@ -12430,12 +12430,12 @@ pub static VARS_HON_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=13,
 };
 
-static VARS_HOM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HOM_CHILDREN),
+static VARS_HOM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HOM_CHILDREN),
     value: None,
 };
 
-pub static VARS_HOM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HOM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("oeopath"),
         dictgen::InsensitiveStr::Ascii("oeopathic"),
@@ -12507,12 +12507,12 @@ pub static VARS_HOM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_HI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HI_CHILDREN),
+static VARS_HI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HI_CHILDREN),
     value: None,
 };
 
-pub static VARS_HI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ccupped"),
         dictgen::InsensitiveStr::Ascii("ccupping"),
@@ -12524,12 +12524,12 @@ pub static VARS_HI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=8,
 };
 
-static VARS_HE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HE_CHILDREN),
+static VARS_HE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HE_CHILDREN),
     value: None,
 };
 
-pub static VARS_HE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("braise"),
         dictgen::InsensitiveStr::Ascii("braised"),
@@ -12653,12 +12653,12 @@ pub static VARS_HE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=12,
 };
 
-static VARS_HA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_HA_CHILDREN),
+static VARS_HA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_HA_CHILDREN),
     value: None,
 };
 
-pub static VARS_HA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_HA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("emal"),
         dictgen::InsensitiveStr::Ascii("ematite"),
@@ -12770,12 +12770,12 @@ pub static VARS_HA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=12,
 };
 
-static VARS_G_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_G_CHILDREN),
+static VARS_G_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_G_CHILDREN),
     value: None,
 };
 
-static VARS_G_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_G_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_GA_NODE),
     None,
     None,
@@ -12804,12 +12804,12 @@ static VARS_G_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_GY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_GY_CHILDREN),
+static VARS_GY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_GY_CHILDREN),
     value: None,
 };
 
-pub static VARS_GY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_GY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("naecological"),
         dictgen::InsensitiveStr::Ascii("naecologicaler"),
@@ -12857,12 +12857,12 @@ pub static VARS_GY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 8..=15,
 };
 
-static VARS_GR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_GR_CHILDREN),
+static VARS_GR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_GR_CHILDREN),
     value: None,
 };
 
-pub static VARS_GR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_GR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aecism"),
         dictgen::InsensitiveStr::Ascii("aecisms"),
@@ -12974,12 +12974,12 @@ pub static VARS_GR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=13,
 };
 
-static VARS_GO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_GO_CHILDREN),
+static VARS_GO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_GO_CHILDREN),
     value: None,
 };
 
-pub static VARS_GO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_GO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iter"),
         dictgen::InsensitiveStr::Ascii("iters"),
@@ -13019,12 +13019,12 @@ pub static VARS_GO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=12,
 };
 
-static VARS_GL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_GL_CHILDREN),
+static VARS_GL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_GL_CHILDREN),
     value: None,
 };
 
-pub static VARS_GL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_GL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amor"),
         dictgen::InsensitiveStr::Ascii("amored"),
@@ -13106,12 +13106,12 @@ pub static VARS_GL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=12,
 };
 
-static VARS_GI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_GI_CHILDREN),
+static VARS_GI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_GI_CHILDREN),
     value: None,
 };
 
-pub static VARS_GI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_GI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gagramme"),
         dictgen::InsensitiveStr::Ascii("gagrammes"),
@@ -13123,12 +13123,12 @@ pub static VARS_GI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 8..=9,
 };
 
-static VARS_GH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_GH_CHILDREN),
+static VARS_GH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_GH_CHILDREN),
     value: None,
 };
 
-pub static VARS_GH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_GH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ettoisation"),
         dictgen::InsensitiveStr::Ascii("ettoisations"),
@@ -13160,12 +13160,12 @@ pub static VARS_GH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=12,
 };
 
-static VARS_GE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_GE_CHILDREN),
+static VARS_GE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_GE_CHILDREN),
     value: None,
 };
 
-pub static VARS_GE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_GE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("latinisation"),
         dictgen::InsensitiveStr::Ascii("latinisations"),
@@ -13257,12 +13257,12 @@ pub static VARS_GE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=14,
 };
 
-static VARS_GA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_GA_CHILDREN),
+static VARS_GA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_GA_CHILDREN),
     value: None,
 };
 
-pub static VARS_GA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_GA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("llicise"),
         dictgen::InsensitiveStr::Ascii("llicised"),
@@ -13352,12 +13352,12 @@ pub static VARS_GA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=12,
 };
 
-static VARS_F_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_F_CHILDREN),
+static VARS_F_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_F_CHILDREN),
     value: None,
 };
 
-static VARS_F_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_F_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_FA_NODE),
     None,
     None,
@@ -13386,12 +13386,12 @@ static VARS_F_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_FU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FU_CHILDREN),
+static VARS_FU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FU_CHILDREN),
     value: None,
 };
 
-pub static VARS_FU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eling"),
@@ -13447,12 +13447,12 @@ pub static VARS_FU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=10,
 };
 
-static VARS_FR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FR_CHILDREN),
+static VARS_FR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FR_CHILDREN),
     value: None,
 };
 
-pub static VARS_FR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aternisation"),
         dictgen::InsensitiveStr::Ascii("aternisations"),
@@ -13484,12 +13484,12 @@ pub static VARS_FR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 8..=13,
 };
 
-static VARS_FO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FO_CHILDREN),
+static VARS_FO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FO_CHILDREN),
     value: None,
 };
 
-pub static VARS_FO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("calisation"),
         dictgen::InsensitiveStr::Ascii("calisations"),
@@ -13589,12 +13589,12 @@ pub static VARS_FO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=12,
 };
 
-static VARS_FL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FL_CHILDREN),
+static VARS_FL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FL_CHILDREN),
     value: None,
 };
 
-pub static VARS_FL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anneled"),
         dictgen::InsensitiveStr::Ascii("annelet"),
@@ -13704,12 +13704,12 @@ pub static VARS_FL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=12,
 };
 
-static VARS_FI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FI_CHILDREN),
+static VARS_FI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FI_CHILDREN),
     value: None,
 };
 
-pub static VARS_FI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ber"),
         dictgen::InsensitiveStr::Ascii("berboard"),
@@ -13809,12 +13809,12 @@ pub static VARS_FI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=15,
 };
 
-static VARS_FE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FE_CHILDREN),
+static VARS_FE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FE_CHILDREN),
     value: None,
 };
 
-pub static VARS_FE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -13934,12 +13934,12 @@ pub static VARS_FE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=13,
 };
 
-static VARS_FA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_FA_CHILDREN),
+static VARS_FA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_FA_CHILDREN),
     value: None,
 };
 
-static VARS_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_FA_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     Some(&VARS_FAC_NODE),
@@ -13968,12 +13968,12 @@ static VARS_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_FAV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FAV_CHILDREN),
+static VARS_FAV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FAV_CHILDREN),
     value: None,
 };
 
-pub static VARS_FAV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FAV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("orable"),
@@ -14065,12 +14065,12 @@ pub static VARS_FAV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=13,
 };
 
-static VARS_FAN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FAN_CHILDREN),
+static VARS_FAN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FAN_CHILDREN),
     value: None,
 };
 
-pub static VARS_FAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FAN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tasise"),
         dictgen::InsensitiveStr::Ascii("tasised"),
@@ -14094,12 +14094,12 @@ pub static VARS_FAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_FAM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FAM_CHILDREN),
+static VARS_FAM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FAM_CHILDREN),
     value: None,
 };
 
-pub static VARS_FAM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FAM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iliarisation"),
         dictgen::InsensitiveStr::Ascii("iliarisations"),
@@ -14131,12 +14131,12 @@ pub static VARS_FAM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=13,
 };
 
-static VARS_FAG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FAG_CHILDREN),
+static VARS_FAG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FAG_CHILDREN),
     value: None,
 };
 
-pub static VARS_FAG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FAG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ot"),
         dictgen::InsensitiveStr::Ascii("oted"),
@@ -14158,12 +14158,12 @@ pub static VARS_FAG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=5,
 };
 
-static VARS_FAE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FAE_CHILDREN),
+static VARS_FAE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FAE_CHILDREN),
     value: None,
 };
 
-pub static VARS_FAE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FAE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cal"),
         dictgen::InsensitiveStr::Ascii("ces"),
@@ -14175,12 +14175,12 @@ pub static VARS_FAE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=3,
 };
 
-static VARS_FAC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_FAC_CHILDREN),
+static VARS_FAC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_FAC_CHILDREN),
     value: None,
 };
 
-pub static VARS_FAC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_FAC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("torisation"),
         dictgen::InsensitiveStr::Ascii("torisations"),
@@ -14212,12 +14212,12 @@ pub static VARS_FAC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_E_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_E_CHILDREN),
+static VARS_E_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_E_CHILDREN),
     value: None,
 };
 
-static VARS_E_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_E_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     Some(&VARS_EC_NODE),
@@ -14246,12 +14246,12 @@ static VARS_E_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_EY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EY_CHILDREN),
+static VARS_EY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EY_CHILDREN),
     value: None,
 };
 
-pub static VARS_EY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rie"),
         dictgen::InsensitiveStr::Ascii("ry"),
@@ -14263,12 +14263,12 @@ pub static VARS_EY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=3,
 };
 
-static VARS_EX_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EX_CHILDREN),
+static VARS_EX_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EX_CHILDREN),
     value: None,
 };
 
-pub static VARS_EX_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EX_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orcize"),
         dictgen::InsensitiveStr::Ascii("orcized"),
@@ -14358,12 +14358,12 @@ pub static VARS_EX_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=14,
 };
 
-static VARS_EV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EV_CHILDREN),
+static VARS_EV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EV_CHILDREN),
     value: None,
 };
 
-pub static VARS_EV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("angelisation"),
         dictgen::InsensitiveStr::Ascii("angelisations"),
@@ -14411,12 +14411,12 @@ pub static VARS_EV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=13,
 };
 
-static VARS_EU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EU_CHILDREN),
+static VARS_EU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EU_CHILDREN),
     value: None,
 };
 
-pub static VARS_EU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logise"),
         dictgen::InsensitiveStr::Ascii("logised"),
@@ -14480,12 +14480,12 @@ pub static VARS_EU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=14,
 };
 
-static VARS_ET_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ET_CHILDREN),
+static VARS_ET_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ET_CHILDREN),
     value: None,
 };
 
-pub static VARS_ET_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ET_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ernalise"),
         dictgen::InsensitiveStr::Ascii("ernalised"),
@@ -14545,12 +14545,12 @@ pub static VARS_ET_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=11,
 };
 
-static VARS_ES_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ES_CHILDREN),
+static VARS_ES_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ES_CHILDREN),
     value: None,
 };
 
-pub static VARS_ES_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ES_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ophagi"),
         dictgen::InsensitiveStr::Ascii("ophagus"),
@@ -14604,12 +14604,12 @@ pub static VARS_ES_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=10,
 };
 
-static VARS_EQ_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EQ_CHILDREN),
+static VARS_EQ_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EQ_CHILDREN),
     value: None,
 };
 
-pub static VARS_EQ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EQ_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ualed"),
         dictgen::InsensitiveStr::Ascii("ualing"),
@@ -14661,12 +14661,12 @@ pub static VARS_EQ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=11,
 };
 
-static VARS_EP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EP_CHILDREN),
+static VARS_EP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EP_CHILDREN),
     value: None,
 };
 
-pub static VARS_EP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aulet"),
         dictgen::InsensitiveStr::Ascii("aulets"),
@@ -14714,12 +14714,12 @@ pub static VARS_EP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=12,
 };
 
-static VARS_EN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EN_CHILDREN),
+static VARS_EN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EN_CHILDREN),
     value: None,
 };
 
-pub static VARS_EN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ameled"),
         dictgen::InsensitiveStr::Ascii("ameler"),
@@ -14861,12 +14861,12 @@ pub static VARS_EN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=11,
 };
 
-static VARS_EM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EM_CHILDREN),
+static VARS_EM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EM_CHILDREN),
     value: None,
 };
 
-pub static VARS_EM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("blematise"),
         dictgen::InsensitiveStr::Ascii("blematised"),
@@ -14950,12 +14950,12 @@ pub static VARS_EM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=12,
 };
 
-static VARS_EL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EL_CHILDREN),
+static VARS_EL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EL_CHILDREN),
     value: None,
 };
 
-pub static VARS_EL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("egise"),
         dictgen::InsensitiveStr::Ascii("egised"),
@@ -14979,12 +14979,12 @@ pub static VARS_EL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=7,
 };
 
-static VARS_EG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EG_CHILDREN),
+static VARS_EG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EG_CHILDREN),
     value: None,
 };
 
-pub static VARS_EG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("is"),
         dictgen::InsensitiveStr::Ascii("ises"),
@@ -14996,12 +14996,12 @@ pub static VARS_EG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 2..=4,
 };
 
-static VARS_ED_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ED_CHILDREN),
+static VARS_ED_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ED_CHILDREN),
     value: None,
 };
 
-pub static VARS_ED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ED_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ema"),
         dictgen::InsensitiveStr::Ascii("emas"),
@@ -15035,12 +15035,12 @@ pub static VARS_ED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=12,
 };
 
-static VARS_EC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_EC_CHILDREN),
+static VARS_EC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_EC_CHILDREN),
     value: None,
 };
 
-pub static VARS_EC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_EC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onomise"),
         dictgen::InsensitiveStr::Ascii("onomised"),
@@ -15072,12 +15072,12 @@ pub static VARS_EC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=9,
 };
 
-static VARS_D_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_D_CHILDREN),
+static VARS_D_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_D_CHILDREN),
     value: None,
 };
 
-static VARS_D_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_D_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -15106,12 +15106,12 @@ static VARS_D_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_DY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DY_CHILDREN),
+static VARS_DY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DY_CHILDREN),
     value: None,
 };
 
-pub static VARS_DY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("spnea"),
         dictgen::InsensitiveStr::Ascii("spneas"),
@@ -15127,12 +15127,12 @@ pub static VARS_DY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=7,
 };
 
-static VARS_DU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DU_CHILDREN),
+static VARS_DU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DU_CHILDREN),
     value: None,
 };
 
-pub static VARS_DU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eler"),
@@ -15168,12 +15168,12 @@ pub static VARS_DU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=7,
 };
 
-static VARS_DR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DR_CHILDREN),
+static VARS_DR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DR_CHILDREN),
     value: None,
 };
 
-pub static VARS_DR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("aftboard"),
         dictgen::InsensitiveStr::Ascii("aftboards"),
@@ -15283,12 +15283,12 @@ pub static VARS_DR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=14,
 };
 
-static VARS_DO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DO_CHILDREN),
+static VARS_DO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DO_CHILDREN),
     value: None,
 };
 
-pub static VARS_DO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gmatise"),
         dictgen::InsensitiveStr::Ascii("gmatised"),
@@ -15328,12 +15328,12 @@ pub static VARS_DO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=9,
 };
 
-static VARS_DI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_DI_CHILDREN),
+static VARS_DI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_DI_CHILDREN),
     value: None,
 };
 
-static VARS_DI_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_DI_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_DIA_NODE),
     None,
     Some(&VARS_DIC_NODE),
@@ -15362,12 +15362,12 @@ static VARS_DI_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_DIV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DIV_CHILDREN),
+static VARS_DIV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DIV_CHILDREN),
     value: None,
 };
 
-pub static VARS_DIV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DIV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("inise"),
         dictgen::InsensitiveStr::Ascii("inised"),
@@ -15391,12 +15391,12 @@ pub static VARS_DIV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=7,
 };
 
-static VARS_DIS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_DIS_CHILDREN),
+static VARS_DIS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_DIS_CHILDREN),
     value: None,
 };
 
-static VARS_DIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_DIS_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     Some(&VARS_DISC_NODE),
@@ -15425,12 +15425,12 @@ static VARS_DIS_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>
     None,
 ];
 
-static VARS_DIST_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DIST_CHILDREN),
+static VARS_DIST_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DIST_CHILDREN),
     value: None,
 };
 
-pub static VARS_DIST_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DIST_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ill"),
         dictgen::InsensitiveStr::Ascii("ills"),
@@ -15442,12 +15442,12 @@ pub static VARS_DIST_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 3..=4,
 };
 
-static VARS_DISO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DISO_CHILDREN),
+static VARS_DISO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DISO_CHILDREN),
     value: None,
 };
 
-pub static VARS_DISO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DISO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rganisation"),
         dictgen::InsensitiveStr::Ascii("rganisations"),
@@ -15479,12 +15479,12 @@ pub static VARS_DISO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 7..=12,
 };
 
-static VARS_DISH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DISH_CHILDREN),
+static VARS_DISH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DISH_CHILDREN),
     value: None,
 };
 
-pub static VARS_DISH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DISH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eveled"),
         dictgen::InsensitiveStr::Ascii("eveling"),
@@ -15556,12 +15556,12 @@ pub static VARS_DISH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 4..=15,
 };
 
-static VARS_DISF_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DISF_CHILDREN),
+static VARS_DISF_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DISF_CHILDREN),
     value: None,
 };
 
-pub static VARS_DISF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DISF_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avor"),
         dictgen::InsensitiveStr::Ascii("avored"),
@@ -15585,12 +15585,12 @@ pub static VARS_DISF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 4..=8,
 };
 
-static VARS_DISE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DISE_CHILDREN),
+static VARS_DISE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DISE_CHILDREN),
     value: None,
 };
 
-pub static VARS_DISE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DISE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mboweled"),
         dictgen::InsensitiveStr::Ascii("mboweling"),
@@ -15606,12 +15606,12 @@ pub static VARS_DISE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 8..=10,
 };
 
-static VARS_DISC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DISC_CHILDREN),
+static VARS_DISC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DISC_CHILDREN),
     value: None,
 };
 
-pub static VARS_DISC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DISC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("olor"),
         dictgen::InsensitiveStr::Ascii("olored"),
@@ -15643,12 +15643,12 @@ pub static VARS_DISC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 4..=11,
 };
 
-static VARS_DIP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DIP_CHILDREN),
+static VARS_DIP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DIP_CHILDREN),
     value: None,
 };
 
-pub static VARS_DIP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DIP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hthongisation"),
         dictgen::InsensitiveStr::Ascii("hthongisations"),
@@ -15680,12 +15680,12 @@ pub static VARS_DIP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 9..=14,
 };
 
-static VARS_DIO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DIO_CHILDREN),
+static VARS_DIO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DIO_CHILDREN),
     value: None,
 };
 
-pub static VARS_DIO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DIO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("pter"),
         dictgen::InsensitiveStr::Ascii("pters"),
@@ -15701,12 +15701,12 @@ pub static VARS_DIO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=5,
 };
 
-static VARS_DIG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DIG_CHILDREN),
+static VARS_DIG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DIG_CHILDREN),
     value: None,
 };
 
-pub static VARS_DIG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DIG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("italise"),
         dictgen::InsensitiveStr::Ascii("italised"),
@@ -15760,23 +15760,23 @@ pub static VARS_DIG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_DIE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DIE_CHILDREN),
+static VARS_DIE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DIE_CHILDREN),
     value: None,
 };
 
-pub static VARS_DIE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DIE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("cious")],
     values: &[&[(0b00001, &ENTRY_DIOECIOUS_755179665025369568)]],
     range: 5..=5,
 };
 
-static VARS_DIC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DIC_CHILDREN),
+static VARS_DIC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DIC_CHILDREN),
     value: None,
 };
 
-pub static VARS_DIC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DIC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hotomise"),
         dictgen::InsensitiveStr::Ascii("hotomised"),
@@ -15800,12 +15800,12 @@ pub static VARS_DIC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=10,
 };
 
-static VARS_DIA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DIA_CHILDREN),
+static VARS_DIA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DIA_CHILDREN),
     value: None,
 };
 
-pub static VARS_DIA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DIA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("led"),
         dictgen::InsensitiveStr::Ascii("ling"),
@@ -15865,12 +15865,12 @@ pub static VARS_DIA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=10,
 };
 
-static VARS_DE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_DE_CHILDREN),
+static VARS_DE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_DE_CHILDREN),
     value: None,
 };
 
-static VARS_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_DE_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     Some(&VARS_DEC_NODE),
@@ -15899,12 +15899,12 @@ static VARS_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_DEV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEV_CHILDREN),
+static VARS_DEV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEV_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iled"),
         dictgen::InsensitiveStr::Ascii("iling"),
@@ -15944,12 +15944,12 @@ pub static VARS_DEV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=12,
 };
 
-static VARS_DET_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DET_CHILDREN),
+static VARS_DET_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DET_CHILDREN),
     value: None,
 };
 
-pub static VARS_DET_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DET_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ribalisation"),
         dictgen::InsensitiveStr::Ascii("ribalisations"),
@@ -15981,12 +15981,12 @@ pub static VARS_DET_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=13,
 };
 
-static VARS_DES_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_DES_CHILDREN),
+static VARS_DES_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_DES_CHILDREN),
     value: None,
 };
 
-static VARS_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_DES_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_DESA_NODE),
     None,
     Some(&VARS_DESC_NODE),
@@ -16015,12 +16015,12 @@ static VARS_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>
     None,
 ];
 
-static VARS_DESU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DESU_CHILDREN),
+static VARS_DESU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DESU_CHILDREN),
     value: None,
 };
 
-pub static VARS_DESU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DESU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lfurization"),
         dictgen::InsensitiveStr::Ascii("lfurizations"),
@@ -16064,12 +16064,12 @@ pub static VARS_DESU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 7..=13,
 };
 
-static VARS_DEST_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEST_CHILDREN),
+static VARS_DEST_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEST_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEST_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEST_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abilisation"),
         dictgen::InsensitiveStr::Ascii("abilise"),
@@ -16097,12 +16097,12 @@ pub static VARS_DEST_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 7..=11,
 };
 
-static VARS_DESP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DESP_CHILDREN),
+static VARS_DESP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DESP_CHILDREN),
     value: None,
 };
 
-pub static VARS_DESP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DESP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("atch"),
         dictgen::InsensitiveStr::Ascii("atched"),
@@ -16118,12 +16118,12 @@ pub static VARS_DESP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 4..=7,
 };
 
-static VARS_DESE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DESE_CHILDREN),
+static VARS_DESE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DESE_CHILDREN),
     value: None,
 };
 
-pub static VARS_DESE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DESE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nsitisation"),
         dictgen::InsensitiveStr::Ascii("nsitisations"),
@@ -16179,23 +16179,23 @@ pub static VARS_DESE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 7..=12,
 };
 
-static VARS_DESC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DESC_CHILDREN),
+static VARS_DESC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DESC_CHILDREN),
     value: None,
 };
 
-pub static VARS_DESC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DESC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("endents")],
     values: &[&[(0b00001, &ENTRY_DESCENDANTS_15651999902366879600)]],
     range: 7..=7,
 };
 
-static VARS_DESA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DESA_CHILDREN),
+static VARS_DESA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DESA_CHILDREN),
     value: None,
 };
 
-pub static VARS_DESA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DESA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("linisation"),
         dictgen::InsensitiveStr::Ascii("linisations"),
@@ -16227,12 +16227,12 @@ pub static VARS_DESA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 6..=11,
 };
 
-static VARS_DEP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_DEP_CHILDREN),
+static VARS_DEP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_DEP_CHILDREN),
     value: None,
 };
 
-static VARS_DEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_DEP_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_DEPA_NODE),
     None,
     None,
@@ -16261,12 +16261,12 @@ static VARS_DEP_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>
     None,
 ];
 
-static VARS_DEPU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEPU_CHILDREN),
+static VARS_DEPU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEPU_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEPU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEPU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tise"),
         dictgen::InsensitiveStr::Ascii("tised"),
@@ -16290,12 +16290,12 @@ pub static VARS_DEPU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 4..=6,
 };
 
-static VARS_DEPR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEPR_CHILDREN),
+static VARS_DEPR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEPR_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEPR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEPR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("essurisation"),
         dictgen::InsensitiveStr::Ascii("essurisations"),
@@ -16327,12 +16327,12 @@ pub static VARS_DEPR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 8..=13,
 };
 
-static VARS_DEPO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEPO_CHILDREN),
+static VARS_DEPO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEPO_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEPO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEPO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("larisation"),
         dictgen::InsensitiveStr::Ascii("larisations"),
@@ -16408,12 +16408,12 @@ pub static VARS_DEPO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 6..=13,
 };
 
-static VARS_DEPE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEPE_CHILDREN),
+static VARS_DEPE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEPE_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEPE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEPE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ndance"),
         dictgen::InsensitiveStr::Ascii("ndances"),
@@ -16453,12 +16453,12 @@ pub static VARS_DEPE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 5..=14,
 };
 
-static VARS_DEPA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEPA_CHILDREN),
+static VARS_DEPA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEPA_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEPA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEPA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rtmentalisation"),
         dictgen::InsensitiveStr::Ascii("rtmentalisations"),
@@ -16490,12 +16490,12 @@ pub static VARS_DEPA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 11..=16,
 };
 
-static VARS_DEO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEO_CHILDREN),
+static VARS_DEO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEO_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dorisation"),
         dictgen::InsensitiveStr::Ascii("dorisations"),
@@ -16535,12 +16535,12 @@ pub static VARS_DEO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_DEN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEN_CHILDREN),
+static VARS_DEN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEN_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ationalisation"),
         dictgen::InsensitiveStr::Ascii("ationalisations"),
@@ -16624,12 +16624,12 @@ pub static VARS_DEN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=15,
 };
 
-static VARS_DEM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_DEM_CHILDREN),
+static VARS_DEM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_DEM_CHILDREN),
     value: None,
 };
 
-static VARS_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_DEM_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_DEMA_NODE),
     None,
     None,
@@ -16658,12 +16658,12 @@ static VARS_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>
     None,
 ];
 
-static VARS_DEMY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEMY_CHILDREN),
+static VARS_DEMY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEMY_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEMY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEMY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thologise"),
         dictgen::InsensitiveStr::Ascii("thologised"),
@@ -16687,12 +16687,12 @@ pub static VARS_DEMY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 9..=11,
 };
 
-static VARS_DEMO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEMO_CHILDREN),
+static VARS_DEMO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEMO_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEMO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEMO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("bilisation"),
         dictgen::InsensitiveStr::Ascii("bilisations"),
@@ -16820,12 +16820,12 @@ pub static VARS_DEMO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 4..=12,
 };
 
-static VARS_DEMI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEMI_CHILDREN),
+static VARS_DEMI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEMI_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEMI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEMI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("litarisation"),
         dictgen::InsensitiveStr::Ascii("litarisations"),
@@ -16881,12 +16881,12 @@ pub static VARS_DEMI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 8..=13,
 };
 
-static VARS_DEME_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEME_CHILDREN),
+static VARS_DEME_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEME_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEME_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEME_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("anor"),
         dictgen::InsensitiveStr::Ascii("anors"),
@@ -16902,12 +16902,12 @@ pub static VARS_DEME_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 4..=6,
 };
 
-static VARS_DEMA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEMA_CHILDREN),
+static VARS_DEMA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEMA_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEMA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEMA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("gnetisation"),
         dictgen::InsensitiveStr::Ascii("gnetisations"),
@@ -16981,12 +16981,12 @@ pub static VARS_DEMA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 3..=14,
 };
 
-static VARS_DEL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEL_CHILDREN),
+static VARS_DEL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEL_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ocalisation"),
         dictgen::InsensitiveStr::Ascii("ocalisations"),
@@ -17018,12 +17018,12 @@ pub static VARS_DEL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_DEI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEI_CHILDREN),
+static VARS_DEI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEI_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("onisation"),
         dictgen::InsensitiveStr::Ascii("onise"),
@@ -17051,12 +17051,12 @@ pub static VARS_DEI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=9,
 };
 
-static VARS_DEH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEH_CHILDREN),
+static VARS_DEH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEH_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("umanisation"),
         dictgen::InsensitiveStr::Ascii("umanisations"),
@@ -17088,12 +17088,12 @@ pub static VARS_DEH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=12,
 };
 
-static VARS_DEF_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DEF_CHILDREN),
+static VARS_DEF_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DEF_CHILDREN),
     value: None,
 };
 
-pub static VARS_DEF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DEF_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ence"),
         dictgen::InsensitiveStr::Ascii("enced"),
@@ -17137,12 +17137,12 @@ pub static VARS_DEF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=14,
 };
 
-static VARS_DEC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_DEC_CHILDREN),
+static VARS_DEC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_DEC_CHILDREN),
     value: None,
 };
 
-static VARS_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_DEC_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_DECA_NODE),
     None,
     None,
@@ -17171,12 +17171,12 @@ static VARS_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>
     None,
 ];
 
-static VARS_DECR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DECR_CHILDREN),
+static VARS_DECR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DECR_CHILDREN),
     value: None,
 };
 
-pub static VARS_DECR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DECR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iminalisation"),
         dictgen::InsensitiveStr::Ascii("iminalisations"),
@@ -17208,12 +17208,12 @@ pub static VARS_DECR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 9..=14,
 };
 
-static VARS_DECO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DECO_CHILDREN),
+static VARS_DECO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DECO_CHILDREN),
     value: None,
 };
 
-pub static VARS_DECO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DECO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lonisation"),
         dictgen::InsensitiveStr::Ascii("lonisations"),
@@ -17245,12 +17245,12 @@ pub static VARS_DECO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 6..=11,
 };
 
-static VARS_DECI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DECI_CHILDREN),
+static VARS_DECI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DECI_CHILDREN),
     value: None,
 };
 
-pub static VARS_DECI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DECI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("liter"),
         dictgen::InsensitiveStr::Ascii("liters"),
@@ -17298,12 +17298,12 @@ pub static VARS_DECI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 5..=11,
 };
 
-static VARS_DECE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DECE_CHILDREN),
+static VARS_DECE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DECE_CHILDREN),
     value: None,
 };
 
-pub static VARS_DECE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DECE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ntralisation"),
         dictgen::InsensitiveStr::Ascii("ntralisations"),
@@ -17335,12 +17335,12 @@ pub static VARS_DECE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 8..=13,
 };
 
-static VARS_DECA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_DECA_CHILDREN),
+static VARS_DECA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_DECA_CHILDREN),
     value: None,
 };
 
-pub static VARS_DECA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_DECA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rbonisation"),
         dictgen::InsensitiveStr::Ascii("rbonisations"),
@@ -17372,12 +17372,12 @@ pub static VARS_DECA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 7..=12,
 };
 
-static VARS_C_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_C_CHILDREN),
+static VARS_C_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_C_CHILDREN),
     value: None,
 };
 
-static VARS_C_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_C_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_CA_NODE),
     None,
     None,
@@ -17406,12 +17406,12 @@ static VARS_C_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_CU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CU_CHILDREN),
+static VARS_CU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CU_CHILDREN),
     value: None,
 };
 
-pub static VARS_CU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dgeled"),
         dictgen::InsensitiveStr::Ascii("dgeling"),
@@ -17463,12 +17463,12 @@ pub static VARS_CU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=12,
 };
 
-static VARS_CR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_CR_CHILDREN),
+static VARS_CR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_CR_CHILDREN),
     value: None,
 };
 
-static VARS_CR_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_CR_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -17497,12 +17497,12 @@ static VARS_CR_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_CRY_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CRY_CHILDREN),
+static VARS_CRY_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CRY_CHILDREN),
     value: None,
 };
 
-pub static VARS_CRY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CRY_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("stalize"),
         dictgen::InsensitiveStr::Ascii("stalized"),
@@ -17558,12 +17558,12 @@ pub static VARS_CRY_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=13,
 };
 
-static VARS_CRU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CRU_CHILDREN),
+static VARS_CRU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CRU_CHILDREN),
     value: None,
 };
 
-pub static VARS_CRU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CRU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eler"),
         dictgen::InsensitiveStr::Ascii("elest"),
@@ -17579,12 +17579,12 @@ pub static VARS_CRU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=6,
 };
 
-static VARS_CRI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CRI_CHILDREN),
+static VARS_CRI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CRI_CHILDREN),
     value: None,
 };
 
-pub static VARS_CRI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CRI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("minalisation"),
         dictgen::InsensitiveStr::Ascii("minalisations"),
@@ -17656,12 +17656,12 @@ pub static VARS_CRI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=13,
 };
 
-static VARS_CRE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CRE_CHILDREN),
+static VARS_CRE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CRE_CHILDREN),
     value: None,
 };
 
-pub static VARS_CRE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CRE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nellate"),
         dictgen::InsensitiveStr::Ascii("nellated"),
@@ -17705,12 +17705,12 @@ pub static VARS_CRE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_CO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_CO_CHILDREN),
+static VARS_CO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_CO_CHILDREN),
     value: None,
 };
 
-static VARS_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_CO_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -17739,12 +17739,12 @@ static VARS_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     Some(&VARS_COZ_NODE),
 ];
 
-static VARS_COZ_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COZ_CHILDREN),
+static VARS_COZ_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COZ_CHILDREN),
     value: None,
 };
 
-pub static VARS_COZ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COZ_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ier"),
@@ -17768,12 +17768,12 @@ pub static VARS_COZ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 1..=5,
 };
 
-static VARS_COU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COU_CHILDREN),
+static VARS_COU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COU_CHILDREN),
     value: None,
 };
 
-pub static VARS_COU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ncillor"),
         dictgen::InsensitiveStr::Ascii("ncillors"),
@@ -17813,12 +17813,12 @@ pub static VARS_COU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=12,
 };
 
-static VARS_COS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COS_CHILDREN),
+static VARS_COS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COS_CHILDREN),
     value: None,
 };
 
-pub static VARS_COS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ied"),
         dictgen::InsensitiveStr::Ascii("ier"),
@@ -17858,12 +17858,12 @@ pub static VARS_COS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 1..=14,
 };
 
-static VARS_COP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COP_CHILDREN),
+static VARS_COP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COP_CHILDREN),
     value: None,
 };
 
-pub static VARS_COP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("olymerise"),
         dictgen::InsensitiveStr::Ascii("olymerised"),
@@ -17887,23 +17887,23 @@ pub static VARS_COP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 9..=11,
 };
 
-static VARS_COO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COO_CHILDREN),
+static VARS_COO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COO_CHILDREN),
     value: None,
 };
 
-pub static VARS_COO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("ky")],
     values: &[&[(0b00001, &ENTRY_COOKIE_9287663065088073450)]],
     range: 2..=2,
 };
 
-static VARS_CON_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CON_CHILDREN),
+static VARS_CON_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CON_CHILDREN),
     value: None,
 };
 
-pub static VARS_CON_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CON_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ceptualisation"),
         dictgen::InsensitiveStr::Ascii("ceptualisations"),
@@ -18043,12 +18043,12 @@ pub static VARS_CON_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=15,
 };
 
-static VARS_COM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COM_CHILDREN),
+static VARS_COM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COM_CHILDREN),
     value: None,
 };
 
-pub static VARS_COM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mercialisation"),
         dictgen::InsensitiveStr::Ascii("mercialisations"),
@@ -18128,12 +18128,12 @@ pub static VARS_COM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 8..=18,
 };
 
-static VARS_COL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_COL_CHILDREN),
+static VARS_COL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_COL_CHILDREN),
     value: None,
 };
 
-static VARS_COL_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_COL_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -18162,12 +18162,12 @@ static VARS_COL_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>
     None,
 ];
 
-static VARS_COLO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_COLO_CHILDREN),
+static VARS_COLO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_COLO_CHILDREN),
     value: None,
 };
 
-static VARS_COLO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_COLO_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -18196,12 +18196,12 @@ static VARS_COLO_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>
     None,
 ];
 
-static VARS_COLOU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COLOU_CHILDREN),
+static VARS_COLOU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COLOU_CHILDREN),
     value: None,
 };
 
-pub static VARS_COLOU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COLOU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("r"),
         dictgen::InsensitiveStr::Ascii("rable"),
@@ -18291,12 +18291,12 @@ pub static VARS_COLOU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dict
     range: 1..=10,
 };
 
-static VARS_COLOR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COLOR_CHILDREN),
+static VARS_COLOR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COLOR_CHILDREN),
     value: Some(&[(0b11001, &ENTRY_COLOR_4390088940109675041)]),
 };
 
-pub static VARS_COLOR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COLOR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("able"),
         dictgen::InsensitiveStr::Ascii("abler"),
@@ -18368,12 +18368,12 @@ pub static VARS_COLOR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dict
     range: 1..=9,
 };
 
-static VARS_COLON_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COLON_CHILDREN),
+static VARS_COLON_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COLON_CHILDREN),
     value: None,
 };
 
-pub static VARS_COLON_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COLON_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("isation"),
         dictgen::InsensitiveStr::Ascii("isations"),
@@ -18413,12 +18413,12 @@ pub static VARS_COLON_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dict
     range: 3..=8,
 };
 
-static VARS_COLL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COLL_CHILDREN),
+static VARS_COLL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COLL_CHILDREN),
     value: None,
 };
 
-pub static VARS_COLL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COLL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ectable"),
         dictgen::InsensitiveStr::Ascii("ectables"),
@@ -18454,12 +18454,12 @@ pub static VARS_COLL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 7..=13,
 };
 
-static VARS_COG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COG_CHILDREN),
+static VARS_COG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COG_CHILDREN),
     value: None,
 };
 
-pub static VARS_COG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nisable"),
         dictgen::InsensitiveStr::Ascii("nisabler"),
@@ -18499,12 +18499,12 @@ pub static VARS_COG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=9,
 };
 
-static VARS_COE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_COE_CHILDREN),
+static VARS_COE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_COE_CHILDREN),
     value: None,
 };
 
-pub static VARS_COE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_COE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lom"),
         dictgen::InsensitiveStr::Ascii("lomata"),
@@ -18526,12 +18526,12 @@ pub static VARS_COE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=9,
 };
 
-static VARS_CL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CL_CHILDREN),
+static VARS_CL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CL_CHILDREN),
     value: None,
 };
 
-pub static VARS_CL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amor"),
         dictgen::InsensitiveStr::Ascii("amored"),
@@ -18595,12 +18595,12 @@ pub static VARS_CL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=11,
 };
 
-static VARS_CI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CI_CHILDREN),
+static VARS_CI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CI_CHILDREN),
     value: None,
 };
 
-pub static VARS_CI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("catrisation"),
         dictgen::InsensitiveStr::Ascii("catrisations"),
@@ -18670,12 +18670,12 @@ pub static VARS_CI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=12,
 };
 
-static VARS_CH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_CH_CHILDREN),
+static VARS_CH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_CH_CHILDREN),
     value: None,
 };
 
-static VARS_CH_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_CH_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_CHA_NODE),
     None,
     None,
@@ -18704,12 +18704,12 @@ static VARS_CH_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_CHR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CHR_CHILDREN),
+static VARS_CHR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CHR_CHILDREN),
     value: None,
 };
 
-pub static VARS_CHR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CHR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("istianisation"),
         dictgen::InsensitiveStr::Ascii("istianisations"),
@@ -18741,12 +18741,12 @@ pub static VARS_CHR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 9..=14,
 };
 
-static VARS_CHI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CHI_CHILDREN),
+static VARS_CHI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CHI_CHILDREN),
     value: None,
 };
 
-pub static VARS_CHI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CHI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("le"),
         dictgen::InsensitiveStr::Ascii("les"),
@@ -18776,12 +18776,12 @@ pub static VARS_CHI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=6,
 };
 
-static VARS_CHE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CHE_CHILDREN),
+static VARS_CHE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CHE_CHILDREN),
     value: None,
 };
 
-pub static VARS_CHE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CHE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ckbook"),
         dictgen::InsensitiveStr::Ascii("ckbooks"),
@@ -18825,12 +18825,12 @@ pub static VARS_CHE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=10,
 };
 
-static VARS_CHA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CHA_CHILDREN),
+static VARS_CHA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CHA_CHILDREN),
     value: None,
 };
 
-pub static VARS_CHA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CHA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("nneled"),
         dictgen::InsensitiveStr::Ascii("nneling"),
@@ -18886,12 +18886,12 @@ pub static VARS_CHA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=14,
 };
 
-static VARS_CE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CE_CHILDREN),
+static VARS_CE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CE_CHILDREN),
     value: None,
 };
 
-pub static VARS_CE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("lom"),
         dictgen::InsensitiveStr::Ascii("loms"),
@@ -18997,12 +18997,12 @@ pub static VARS_CE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=13,
 };
 
-static VARS_CA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_CA_CHILDREN),
+static VARS_CA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_CA_CHILDREN),
     value: None,
 };
 
-static VARS_CA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_CA_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -19031,12 +19031,12 @@ static VARS_CA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_CAV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CAV_CHILDREN),
+static VARS_CAV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CAV_CHILDREN),
     value: None,
 };
 
-pub static VARS_CAV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CAV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("iare"),
         dictgen::InsensitiveStr::Ascii("iares"),
@@ -19068,12 +19068,12 @@ pub static VARS_CAV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=7,
 };
 
-static VARS_CAU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CAU_CHILDREN),
+static VARS_CAU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CAU_CHILDREN),
     value: None,
 };
 
-pub static VARS_CAU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CAU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("terisation"),
         dictgen::InsensitiveStr::Ascii("terisations"),
@@ -19105,12 +19105,12 @@ pub static VARS_CAU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_CAT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CAT_CHILDREN),
+static VARS_CAT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CAT_CHILDREN),
     value: None,
 };
 
-pub static VARS_CAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CAT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alog"),
         dictgen::InsensitiveStr::Ascii("aloged"),
@@ -19224,12 +19224,12 @@ pub static VARS_CAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=13,
 };
 
-static VARS_CAR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CAR_CHILDREN),
+static VARS_CAR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CAR_CHILDREN),
     value: None,
 };
 
-pub static VARS_CAR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CAR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("amelisation"),
         dictgen::InsensitiveStr::Ascii("amelisations"),
@@ -19317,12 +19317,12 @@ pub static VARS_CAR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=12,
 };
 
-static VARS_CAP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CAP_CHILDREN),
+static VARS_CAP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CAP_CHILDREN),
     value: None,
 };
 
-pub static VARS_CAP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CAP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("italisation"),
         dictgen::InsensitiveStr::Ascii("italisations"),
@@ -19386,12 +19386,12 @@ pub static VARS_CAP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=12,
 };
 
-static VARS_CAN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CAN_CHILDREN),
+static VARS_CAN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CAN_CHILDREN),
     value: None,
 };
 
-pub static VARS_CAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CAN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("alisation"),
         dictgen::InsensitiveStr::Ascii("alisations"),
@@ -19497,12 +19497,12 @@ pub static VARS_CAN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=13,
 };
 
-static VARS_CAL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CAL_CHILDREN),
+static VARS_CAL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CAL_CHILDREN),
     value: None,
 };
 
-pub static VARS_CAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CAL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dron"),
         dictgen::InsensitiveStr::Ascii("drons"),
@@ -19555,12 +19555,12 @@ pub static VARS_CAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 1..=8,
 };
 
-static VARS_CAE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_CAE_CHILDREN),
+static VARS_CAE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_CAE_CHILDREN),
     value: None,
 };
 
-pub static VARS_CAE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_CAE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("sium"),
         dictgen::InsensitiveStr::Ascii("siums"),
@@ -19574,12 +19574,12 @@ pub static VARS_CAE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=5,
 };
 
-static VARS_B_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_B_CHILDREN),
+static VARS_B_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_B_CHILDREN),
     value: None,
 };
 
-static VARS_B_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_B_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_BA_NODE),
     None,
     None,
@@ -19608,12 +19608,12 @@ static VARS_B_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_BU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BU_CHILDREN),
+static VARS_BU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BU_CHILDREN),
     value: None,
 };
 
-pub static VARS_BU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("reaucratisation"),
         dictgen::InsensitiveStr::Ascii("reaucratisations"),
@@ -19663,12 +19663,12 @@ pub static VARS_BU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=16,
 };
 
-static VARS_BR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BR_CHILDREN),
+static VARS_BR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BR_CHILDREN),
     value: None,
 };
 
-pub static VARS_BR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BR_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eathalyse"),
         dictgen::InsensitiveStr::Ascii("eathalysed"),
@@ -19722,12 +19722,12 @@ pub static VARS_BR_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=12,
 };
 
-static VARS_BO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BO_CHILDREN),
+static VARS_BO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BO_CHILDREN),
     value: None,
 };
 
-pub static VARS_BO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("tanise"),
         dictgen::InsensitiveStr::Ascii("tanised"),
@@ -19779,23 +19779,23 @@ pub static VARS_BO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=13,
 };
 
-static VARS_BL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BL_CHILDREN),
+static VARS_BL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BL_CHILDREN),
     value: None,
 };
 
-pub static VARS_BL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("amable")],
     values: &[&[(0b01001, &ENTRY_BLAMABLE_2805926222821580419)]],
     range: 6..=6,
 };
 
-static VARS_BI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BI_CHILDREN),
+static VARS_BI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BI_CHILDREN),
     value: None,
 };
 
-pub static VARS_BI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("assed"),
         dictgen::InsensitiveStr::Ascii("assing"),
@@ -19817,12 +19817,12 @@ pub static VARS_BI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 4..=6,
 };
 
-static VARS_BE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_BE_CHILDREN),
+static VARS_BE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_BE_CHILDREN),
     value: None,
 };
 
-static VARS_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_BE_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -19851,12 +19851,12 @@ static VARS_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_BEV_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BEV_CHILDREN),
+static VARS_BEV_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BEV_CHILDREN),
     value: None,
 };
 
-pub static VARS_BEV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BEV_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eled"),
         dictgen::InsensitiveStr::Ascii("eler"),
@@ -19884,12 +19884,12 @@ pub static VARS_BEV_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=7,
 };
 
-static VARS_BEL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BEL_CHILDREN),
+static VARS_BEL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BEL_CHILDREN),
     value: None,
 };
 
-pub static VARS_BEL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BEL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abor"),
         dictgen::InsensitiveStr::Ascii("abored"),
@@ -19913,12 +19913,12 @@ pub static VARS_BEL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=8,
 };
 
-static VARS_BEJ_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BEJ_CHILDREN),
+static VARS_BEJ_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BEJ_CHILDREN),
     value: None,
 };
 
-pub static VARS_BEJ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BEJ_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eweled"),
         dictgen::InsensitiveStr::Ascii("eweling"),
@@ -19934,12 +19934,12 @@ pub static VARS_BEJ_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_BEH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BEH_CHILDREN),
+static VARS_BEH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BEH_CHILDREN),
     value: None,
 };
 
-pub static VARS_BEH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BEH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("avior"),
         dictgen::InsensitiveStr::Ascii("avioral"),
@@ -20023,12 +20023,12 @@ pub static VARS_BEH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=14,
 };
 
-static VARS_BED_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BED_CHILDREN),
+static VARS_BED_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BED_CHILDREN),
     value: None,
 };
 
-pub static VARS_BED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BED_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eviled"),
         dictgen::InsensitiveStr::Ascii("eviling"),
@@ -20044,12 +20044,12 @@ pub static VARS_BED_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_BA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_BA_CHILDREN),
+static VARS_BA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_BA_CHILDREN),
     value: None,
 };
 
-pub static VARS_BA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_BA_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cterias"),
         dictgen::InsensitiveStr::Ascii("lkanisation"),
@@ -20169,12 +20169,12 @@ pub static VARS_BA_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=13,
 };
 
-static VARS_A_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_A_CHILDREN),
+static VARS_A_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_A_CHILDREN),
     value: None,
 };
 
-static VARS_A_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_A_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     Some(&VARS_AB_NODE),
     Some(&VARS_AC_NODE),
@@ -20203,23 +20203,23 @@ static VARS_A_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_AX_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AX_CHILDREN),
+static VARS_AX_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AX_CHILDREN),
     value: Some(&[(0b00001, &ENTRY_AX_8791902263575839056)]),
 };
 
-pub static VARS_AX_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AX_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[dictgen::InsensitiveStr::Ascii("e")],
     values: &[&[(0b11010, &ENTRY_AX_8791902263575839056)]],
     range: 1..=1,
 };
 
-static VARS_AU_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AU_CHILDREN),
+static VARS_AU_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AU_CHILDREN),
     value: None,
 };
 
-pub static VARS_AU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AU_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("thorisation"),
         dictgen::InsensitiveStr::Ascii("thorisations"),
@@ -20275,12 +20275,12 @@ pub static VARS_AU_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=13,
 };
 
-static VARS_AT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AT_CHILDREN),
+static VARS_AT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AT_CHILDREN),
     value: None,
 };
 
-pub static VARS_AT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("omisation"),
         dictgen::InsensitiveStr::Ascii("omisations"),
@@ -20340,12 +20340,12 @@ pub static VARS_AT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=13,
 };
 
-static VARS_AS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AS_CHILDREN),
+static VARS_AS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AS_CHILDREN),
     value: None,
 };
 
-pub static VARS_AS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("afetida"),
         dictgen::InsensitiveStr::Ascii("afetidas"),
@@ -20371,12 +20371,12 @@ pub static VARS_AS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=9,
 };
 
-static VARS_AR_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_AR_CHILDREN),
+static VARS_AR_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_AR_CHILDREN),
     value: None,
 };
 
-static VARS_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_AR_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     Some(&VARS_ARB_NODE),
     Some(&VARS_ARC_NODE),
@@ -20405,12 +20405,12 @@ static VARS_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_ART_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ART_CHILDREN),
+static VARS_ART_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ART_CHILDREN),
     value: None,
 };
 
-pub static VARS_ART_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ART_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("efact"),
         dictgen::InsensitiveStr::Ascii("efacts"),
@@ -20450,12 +20450,12 @@ pub static VARS_ART_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=13,
 };
 
-static VARS_ARS_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ARS_CHILDREN),
+static VARS_ARS_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ARS_CHILDREN),
     value: None,
 };
 
-pub static VARS_ARS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ARS_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("e"),
         dictgen::InsensitiveStr::Ascii("ehole"),
@@ -20471,12 +20471,12 @@ pub static VARS_ARS_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 1..=6,
 };
 
-static VARS_ARO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ARO_CHILDREN),
+static VARS_ARO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ARO_CHILDREN),
     value: None,
 };
 
-pub static VARS_ARO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ARO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("matisation"),
         dictgen::InsensitiveStr::Ascii("matise"),
@@ -20504,12 +20504,12 @@ pub static VARS_ARO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=10,
 };
 
-static VARS_ARM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ARM_CHILDREN),
+static VARS_ARM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ARM_CHILDREN),
     value: None,
 };
 
-pub static VARS_ARM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ARM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("ored"),
@@ -20549,12 +20549,12 @@ pub static VARS_ARM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=6,
 };
 
-static VARS_ARD_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ARD_CHILDREN),
+static VARS_ARD_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ARD_CHILDREN),
     value: None,
 };
 
-pub static VARS_ARD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ARD_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("ors"),
@@ -20570,12 +20570,12 @@ pub static VARS_ARD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=4,
 };
 
-static VARS_ARC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ARC_CHILDREN),
+static VARS_ARC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ARC_CHILDREN),
     value: None,
 };
 
-pub static VARS_ARC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ARC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("haise"),
         dictgen::InsensitiveStr::Ascii("haised"),
@@ -20611,12 +20611,12 @@ pub static VARS_ARC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=10,
 };
 
-static VARS_ARB_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ARB_CHILDREN),
+static VARS_ARB_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ARB_CHILDREN),
     value: None,
 };
 
-pub static VARS_ARB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ARB_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("or"),
         dictgen::InsensitiveStr::Ascii("ored"),
@@ -20648,12 +20648,12 @@ pub static VARS_ARB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=10,
 };
 
-static VARS_AP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_AP_CHILDREN),
+static VARS_AP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_AP_CHILDREN),
     value: None,
 };
 
-static VARS_AP_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_AP_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -20682,12 +20682,12 @@ static VARS_AP_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_APP_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_APP_CHILDREN),
+static VARS_APP_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_APP_CHILDREN),
     value: None,
 };
 
-pub static VARS_APP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_APP_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("al"),
         dictgen::InsensitiveStr::Ascii("all"),
@@ -20739,12 +20739,12 @@ pub static VARS_APP_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=9,
 };
 
-static VARS_APO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_APO_CHILDREN),
+static VARS_APO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_APO_CHILDREN),
     value: None,
 };
 
-pub static VARS_APO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_APO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("logise"),
         dictgen::InsensitiveStr::Ascii("logised"),
@@ -20816,12 +20816,12 @@ pub static VARS_APO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_APN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_APN_CHILDREN),
+static VARS_APN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_APN_CHILDREN),
     value: None,
 };
 
-pub static VARS_APN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_APN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ea"),
         dictgen::InsensitiveStr::Ascii("eas"),
@@ -20837,12 +20837,12 @@ pub static VARS_APN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 2..=4,
 };
 
-static VARS_APH_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_APH_CHILDREN),
+static VARS_APH_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_APH_CHILDREN),
     value: None,
 };
 
-pub static VARS_APH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_APH_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("orise"),
         dictgen::InsensitiveStr::Ascii("orised"),
@@ -20866,12 +20866,12 @@ pub static VARS_APH_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 5..=7,
 };
 
-static VARS_AN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_AN_CHILDREN),
+static VARS_AN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_AN_CHILDREN),
     value: None,
 };
 
-static VARS_AN_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_AN_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     Some(&VARS_ANA_NODE),
     None,
     None,
@@ -20900,12 +20900,12 @@ static VARS_AN_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>;
     None,
 ];
 
-static VARS_ANT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANT_CHILDREN),
+static VARS_ANT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANT_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("agonise"),
         dictgen::InsensitiveStr::Ascii("agonised"),
@@ -20961,12 +20961,12 @@ pub static VARS_ANT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 7..=15,
 };
 
-static VARS_ANO_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANO_CHILDREN),
+static VARS_ANO_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANO_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANO_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("dise"),
         dictgen::InsensitiveStr::Ascii("dised"),
@@ -20990,12 +20990,12 @@ pub static VARS_ANO_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 4..=6,
 };
 
-static VARS_ANN_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANN_CHILDREN),
+static VARS_ANN_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANN_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANN_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ualise"),
         dictgen::InsensitiveStr::Ascii("ualised"),
@@ -21019,12 +21019,12 @@ pub static VARS_ANN_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=8,
 };
 
-static VARS_ANI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANI_CHILDREN),
+static VARS_ANI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANI_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("malisation"),
         dictgen::InsensitiveStr::Ascii("malisations"),
@@ -21056,12 +21056,12 @@ pub static VARS_ANI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_ANG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANG_CHILDREN),
+static VARS_ANG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANG_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("licisation"),
         dictgen::InsensitiveStr::Ascii("licisations"),
@@ -21093,12 +21093,12 @@ pub static VARS_ANG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 6..=11,
 };
 
-static VARS_ANE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANE_CHILDREN),
+static VARS_ANE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANE_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mia"),
         dictgen::InsensitiveStr::Ascii("mias"),
@@ -21166,12 +21166,12 @@ pub static VARS_ANE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictge
     range: 3..=14,
 };
 
-static VARS_ANA_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Nested(&VARS_ANA_CHILDREN),
+static VARS_ANA_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Nested(&VARS_ANA_CHILDREN),
     value: None,
 };
 
-static VARS_ANA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>; 26] = [
+static VARS_ANA_CHILDREN: [Option<&dictgen::TrieNode<&[(u8, &VariantsMap)]>>; 26] = [
     None,
     None,
     None,
@@ -21200,12 +21200,12 @@ static VARS_ANA_CHILDREN: [Option<&dictgen::DictTrieNode<&[(u8, &VariantsMap)]>>
     None,
 ];
 
-static VARS_ANAT_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANAT_CHILDREN),
+static VARS_ANAT_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANAT_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANAT_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("hematise"),
         dictgen::InsensitiveStr::Ascii("hematised"),
@@ -21245,12 +21245,12 @@ pub static VARS_ANAT_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 5..=10,
 };
 
-static VARS_ANAL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANAL_CHILDREN),
+static VARS_ANAL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANAL_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANAL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ogise"),
         dictgen::InsensitiveStr::Ascii("ogised"),
@@ -21308,12 +21308,12 @@ pub static VARS_ANAL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 3..=8,
 };
 
-static VARS_ANAG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANAG_CHILDREN),
+static VARS_ANAG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANAG_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANAG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANAG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rammatise"),
         dictgen::InsensitiveStr::Ascii("rammatised"),
@@ -21337,12 +21337,12 @@ pub static VARS_ANAG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 9..=11,
 };
 
-static VARS_ANAE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_ANAE_CHILDREN),
+static VARS_ANAE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_ANAE_CHILDREN),
     value: None,
 };
 
-pub static VARS_ANAE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_ANAE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("mia"),
         dictgen::InsensitiveStr::Ascii("mias"),
@@ -21410,12 +21410,12 @@ pub static VARS_ANAE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictg
     range: 3..=14,
 };
 
-static VARS_AM_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AM_CHILDREN),
+static VARS_AM_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AM_CHILDREN),
     value: None,
 };
 
-pub static VARS_AM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AM_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("eba"),
         dictgen::InsensitiveStr::Ascii("ebae"),
@@ -21497,12 +21497,12 @@ pub static VARS_AM_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=14,
 };
 
-static VARS_AL_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AL_CHILDREN),
+static VARS_AL_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AL_CHILDREN),
     value: None,
 };
 
-pub static VARS_AL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AL_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("chemise"),
         dictgen::InsensitiveStr::Ascii("chemised"),
@@ -21616,12 +21616,12 @@ pub static VARS_AL_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 3..=14,
 };
 
-static VARS_AI_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AI_CHILDREN),
+static VARS_AI_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AI_CHILDREN),
     value: None,
 };
 
-pub static VARS_AI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AI_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rfoil"),
         dictgen::InsensitiveStr::Ascii("rfoils"),
@@ -21637,12 +21637,12 @@ pub static VARS_AI_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=7,
 };
 
-static VARS_AG_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AG_CHILDREN),
+static VARS_AG_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AG_CHILDREN),
     value: None,
 };
 
-pub static VARS_AG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AG_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("grandise"),
         dictgen::InsensitiveStr::Ascii("grandised"),
@@ -21710,12 +21710,12 @@ pub static VARS_AG_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 5..=13,
 };
 
-static VARS_AF_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AF_CHILDREN),
+static VARS_AF_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AF_CHILDREN),
     value: None,
 };
 
-pub static VARS_AF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AF_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("ricanise"),
         dictgen::InsensitiveStr::Ascii("ricanised"),
@@ -21741,12 +21741,12 @@ pub static VARS_AF_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 7..=10,
 };
 
-static VARS_AE_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AE_CHILDREN),
+static VARS_AE_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AE_CHILDREN),
     value: None,
 };
 
-pub static VARS_AE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AE_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("rofoil"),
         dictgen::InsensitiveStr::Ascii("rofoils"),
@@ -21782,12 +21782,12 @@ pub static VARS_AE_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=12,
 };
 
-static VARS_AD_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AD_CHILDREN),
+static VARS_AD_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AD_CHILDREN),
     value: None,
 };
 
-pub static VARS_AD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AD_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("vertize"),
         dictgen::InsensitiveStr::Ascii("vertized"),
@@ -21809,12 +21809,12 @@ pub static VARS_AD_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 1..=12,
 };
 
-static VARS_AC_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AC_CHILDREN),
+static VARS_AC_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AC_CHILDREN),
     value: None,
 };
 
-pub static VARS_AC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AC_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("cessorise"),
         dictgen::InsensitiveStr::Ascii("cessorised"),
@@ -21898,12 +21898,12 @@ pub static VARS_AC_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen
     range: 6..=13,
 };
 
-static VARS_AB_NODE: dictgen::DictTrieNode<&[(u8, &VariantsMap)]> = dictgen::DictTrieNode {
-    children: dictgen::DictTrieChild::Flat(&VARS_AB_CHILDREN),
+static VARS_AB_NODE: dictgen::TrieNode<&[(u8, &VariantsMap)]> = dictgen::TrieNode {
+    children: dictgen::TrieChild::Flat(&VARS_AB_CHILDREN),
     value: None,
 };
 
-pub static VARS_AB_CHILDREN: dictgen::DictTable<&[(u8, &VariantsMap)]> = dictgen::DictTable {
+pub static VARS_AB_CHILDREN: dictgen::OrderedMap<&[(u8, &VariantsMap)]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("etter"),
         dictgen::InsensitiveStr::Ascii("etters"),
diff --git a/crates/wikipedia-dict/src/dict_codegen.rs b/crates/wikipedia-dict/src/dict_codegen.rs
index 38a6e7e..a347853 100644
--- a/crates/wikipedia-dict/src/dict_codegen.rs
+++ b/crates/wikipedia-dict/src/dict_codegen.rs
@@ -1,6 +1,6 @@
 // This file is @generated by crates/wikipedia-dict/tests/codegen.rs
 
-pub static WORD_DICTIONARY: dictgen::DictTable<&[&str]> = dictgen::DictTable {
+pub static WORD_DICTIONARY: dictgen::OrderedMap<&[&str]> = dictgen::OrderedMap {
     keys: &[
         dictgen::InsensitiveStr::Ascii("abandonned"),
         dictgen::InsensitiveStr::Ascii("abbout"),
diff --git a/crates/wikipedia-dict/tests/codegen.rs b/crates/wikipedia-dict/tests/codegen.rs
index e729090..878cb39 100644
--- a/crates/wikipedia-dict/tests/codegen.rs
+++ b/crates/wikipedia-dict/tests/codegen.rs
@@ -24,7 +24,7 @@ fn generate<W: std::io::Write>(file: &mut W) {
     dictgen::DictGen::new()
         .name("WORD_DICTIONARY")
         .value_type("&[&str]")
-        .table()
+        .ordered_map()
         .write(file, dict.map(|kv| (kv.0, format!("&{:?}", kv.1))))
         .unwrap();
 }